1 using System;
2 using System.Collections;
3 using System.Text.Parsing;
4 using cppast;
5
6
7
8 namespace cppparser
9 {
10 public class ExpressionGrammar : System.Text.Parsing.Grammar
11 {
12 public ExpressionGrammar() : this(new ParsingDomain())
13 {
14 }
15 public ExpressionGrammar(ParsingDomain* parsingDomain) : base(ToUtf32("ExpressionGrammar"), parsingDomain->GetNamespaceScope(ToUtf32("cppparser")), parsingDomain)
16 {
17 SetOwner(0);
18 RegisterParsingDomain(parsingDomain);
19 parsingDomain->AddGrammar(this);
20 CreateRules();
21 Link();
22 }
23 public ExpressionListNode* Parse(const uchar* start, const uchar* end, int fileIndex, const string& fileName, ParsingContext* ctx)
24 {
25 Scanner scanner(start, end, fileName, fileIndex, SkipRule());
26 UniquePtr<XmlLog> xmlLog;
27 if (Log() != null)
28 {
29 xmlLog.Reset(new XmlLog(*Log(), MaxLogLineLength()));
30 scanner.SetLog(xmlLog.Get());
31 xmlLog->WriteBeginRule( u"parse");
32 xmlLog->IncIndent();
33 }
34 Stack<UniquePtr<Object>> stack;
35 UniquePtr<ParsingData> parsingData(new ParsingData(Domain()->NumRules()));
36 scanner.SetParsingData(parsingData.Get());
37 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(ctx)));
38 Match match = base->Parse(scanner, stack, parsingData.Get());
39 Span stop = scanner.GetSpan();
40 if (Log() != null)
41 {
42 xmlLog->DecIndent();
43 xmlLog->WriteEndRule( u"parse");
44 }
45 if (!match.Hit() || stop.start != cast<int>(end - start))
46 {
47 if (StartRule() != null)
48 {
49 throw ExpectationFailure(StartRule()->Info(), fileName, stop, start, end);
50 }
51 else
52 {
53 throw ParsingException("grammar '" + ToUtf8(Name()) + "' has no start rule", fileName, scanner.GetSpan(), start, end);
54 }
55 }
56 UniquePtr<Object> value = stack.Pop();
57 ExpressionListNode* result = *cast<ValueObject<ExpressionListNode*>*>(value.Get());
58 return result;
59 }
60
61 public class ExpressionListRule : System.Text.Parsing.RuleParser
62 {
63 public ExpressionListRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
64 {
65 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
66 SetValueTypeName(ToUtf32("ExpressionListNode*"));
67 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<ExpressionListNode>"), ToUtf32("node")));
68 }
69 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
70 {
71 parsingData->PushContext(Id(), new Context());
72 Context* context = cast<Context*>(parsingData->GetContext(Id()));
73 UniquePtr<Object> ctx_value = stack.Pop();
74 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
75 }
76 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
77 {
78 Context* context = cast<Context*>(parsingData->GetContext(Id()));
79 if (matched)
80 {
81 stack.Push(UniquePtr<Object>(new ValueObject<ExpressionListNode*>(context->value)));
82 }
83 parsingData->PopContext(Id());
84 }
85 public override void Link()
86 {
87 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
88 a0ActionParser->SetAction(A0Action);
89 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
90 a1ActionParser->SetAction(A1Action);
91 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
92 a2ActionParser->SetAction(A2Action);
93 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
94 a3ActionParser->SetAction(A3Action);
95 NonterminalParser* ic1NonterminalParser = GetNonterminal(ToUtf32("ic1"));
96 ic1NonterminalParser->SetPre(Preic1);
97 ic1NonterminalParser->SetPost(Postic1);
98 NonterminalParser* ic2NonterminalParser = GetNonterminal(ToUtf32("ic2"));
99 ic2NonterminalParser->SetPre(Preic2);
100 ic2NonterminalParser->SetPost(Postic2);
101 }
102 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
103 {
104 Context* context = cast<Context*>(parsingData->GetContext(Id()));
105 context->value = context->node.Release();
106 }
107 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
108 {
109 Context* context = cast<Context*>(parsingData->GetContext(Id()));
110 context->node.Reset(new ExpressionListNode(span));
111 }
112 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
113 {
114 Context* context = cast<Context*>(parsingData->GetContext(Id()));
115 context->node->AddNode(context->fromic1);
116 }
117 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
118 {
119 Context* context = cast<Context*>(parsingData->GetContext(Id()));
120 context->node->AddNode(context->fromic2);
121 }
122 public void Preic1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
123 {
124 Context* context = cast<Context*>(parsingData->GetContext(Id()));
125 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
126 }
127 public void Postic1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
128 {
129 Context* context = cast<Context*>(parsingData->GetContext(Id()));
130 if (matched)
131 {
132 UniquePtr<Object> fromic1_value = stack.Pop();
133 context->fromic1 = *cast<ValueObject<Node*>*>(fromic1_value.Get());
134 }
135 }
136 public void Preic2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
137 {
138 Context* context = cast<Context*>(parsingData->GetContext(Id()));
139 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
140 }
141 public void Postic2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
142 {
143 Context* context = cast<Context*>(parsingData->GetContext(Id()));
144 if (matched)
145 {
146 UniquePtr<Object> fromic2_value = stack.Pop();
147 context->fromic2 = *cast<ValueObject<Node*>*>(fromic2_value.Get());
148 }
149 }
150 public class Context : System.Text.Parsing.Context
151 {
152 public Context() : ctx(), value(), node(), fromic1(), fromic2()
153 {
154 }
155 public ParsingContext* ctx;
156 public ExpressionListNode* value;
157 public UniquePtr<ExpressionListNode> node;
158 public Node* fromic1;
159 public Node* fromic2;
160 }
161 }
162
163 public class PossiblyEmptyArgumentListRule : System.Text.Parsing.RuleParser
164 {
165 public PossiblyEmptyArgumentListRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
166 {
167 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
168 SetValueTypeName(ToUtf32("ExpressionListNode*"));
169 }
170 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
171 {
172 parsingData->PushContext(Id(), new Context());
173 Context* context = cast<Context*>(parsingData->GetContext(Id()));
174 UniquePtr<Object> ctx_value = stack.Pop();
175 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
176 }
177 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
178 {
179 Context* context = cast<Context*>(parsingData->GetContext(Id()));
180 if (matched)
181 {
182 stack.Push(UniquePtr<Object>(new ValueObject<ExpressionListNode*>(context->value)));
183 }
184 parsingData->PopContext(Id());
185 }
186 public override void Link()
187 {
188 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
189 a0ActionParser->SetAction(A0Action);
190 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
191 a1ActionParser->SetAction(A1Action);
192 NonterminalParser* expressionListNonterminalParser = GetNonterminal(ToUtf32("ExpressionList"));
193 expressionListNonterminalParser->SetPre(PreExpressionList);
194 expressionListNonterminalParser->SetPost(PostExpressionList);
195 }
196 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
197 {
198 Context* context = cast<Context*>(parsingData->GetContext(Id()));
199 context->value = context->fromExpressionList;
200 }
201 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
202 {
203 Context* context = cast<Context*>(parsingData->GetContext(Id()));
204 context->value = new ExpressionListNode(span);
205 }
206 public void PreExpressionList(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
207 {
208 Context* context = cast<Context*>(parsingData->GetContext(Id()));
209 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
210 }
211 public void PostExpressionList(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
212 {
213 Context* context = cast<Context*>(parsingData->GetContext(Id()));
214 if (matched)
215 {
216 UniquePtr<Object> fromExpressionList_value = stack.Pop();
217 context->fromExpressionList = *cast<ValueObject<ExpressionListNode*>*>(fromExpressionList_value.Get());
218 }
219 }
220 public class Context : System.Text.Parsing.Context
221 {
222 public Context() : ctx(), value(), fromExpressionList()
223 {
224 }
225 public ParsingContext* ctx;
226 public ExpressionListNode* value;
227 public ExpressionListNode* fromExpressionList;
228 }
229 }
230
231 public class ExpressionRule : System.Text.Parsing.RuleParser
232 {
233 public ExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
234 {
235 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
236 SetValueTypeName(ToUtf32("Node*"));
237 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
238 }
239 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
240 {
241 parsingData->PushContext(Id(), new Context());
242 Context* context = cast<Context*>(parsingData->GetContext(Id()));
243 UniquePtr<Object> ctx_value = stack.Pop();
244 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
245 }
246 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
247 {
248 Context* context = cast<Context*>(parsingData->GetContext(Id()));
249 if (matched)
250 {
251 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
252 }
253 parsingData->PopContext(Id());
254 }
255 public override void Link()
256 {
257 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
258 a0ActionParser->SetAction(A0Action);
259 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
260 a1ActionParser->SetAction(A1Action);
261 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
262 a2ActionParser->SetAction(A2Action);
263 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
264 leftNonterminalParser->SetPre(Preleft);
265 leftNonterminalParser->SetPost(Postleft);
266 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
267 rightNonterminalParser->SetPre(Preright);
268 rightNonterminalParser->SetPost(Postright);
269 }
270 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
271 {
272 Context* context = cast<Context*>(parsingData->GetContext(Id()));
273 context->value = context->node.Release();
274 }
275 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
276 {
277 Context* context = cast<Context*>(parsingData->GetContext(Id()));
278 context->node.Reset(context->fromleft);
279 }
280 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
281 {
282 Context* context = cast<Context*>(parsingData->GetContext(Id()));
283 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, Operator.comma));
284 }
285 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
286 {
287 Context* context = cast<Context*>(parsingData->GetContext(Id()));
288 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
289 }
290 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
291 {
292 Context* context = cast<Context*>(parsingData->GetContext(Id()));
293 if (matched)
294 {
295 UniquePtr<Object> fromleft_value = stack.Pop();
296 context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
297 }
298 }
299 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
300 {
301 Context* context = cast<Context*>(parsingData->GetContext(Id()));
302 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
303 }
304 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
305 {
306 Context* context = cast<Context*>(parsingData->GetContext(Id()));
307 if (matched)
308 {
309 UniquePtr<Object> fromright_value = stack.Pop();
310 context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
311 }
312 }
313 public class Context : System.Text.Parsing.Context
314 {
315 public Context() : ctx(), value(), node(), fromleft(), fromright()
316 {
317 }
318 public ParsingContext* ctx;
319 public Node* value;
320 public UniquePtr<Node> node;
321 public Node* fromleft;
322 public Node* fromright;
323 }
324 }
325
326 public class ConstantExpressionRule : System.Text.Parsing.RuleParser
327 {
328 public ConstantExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
329 {
330 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
331 SetValueTypeName(ToUtf32("Node*"));
332 }
333 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
334 {
335 parsingData->PushContext(Id(), new Context());
336 Context* context = cast<Context*>(parsingData->GetContext(Id()));
337 UniquePtr<Object> ctx_value = stack.Pop();
338 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
339 }
340 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
341 {
342 Context* context = cast<Context*>(parsingData->GetContext(Id()));
343 if (matched)
344 {
345 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
346 }
347 parsingData->PopContext(Id());
348 }
349 public override void Link()
350 {
351 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
352 a0ActionParser->SetAction(A0Action);
353 NonterminalParser* conditionalExpressionNonterminalParser = GetNonterminal(ToUtf32("ConditionalExpression"));
354 conditionalExpressionNonterminalParser->SetPre(PreConditionalExpression);
355 conditionalExpressionNonterminalParser->SetPost(PostConditionalExpression);
356 }
357 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
358 {
359 Context* context = cast<Context*>(parsingData->GetContext(Id()));
360 context->value = context->fromConditionalExpression;
361 }
362 public void PreConditionalExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
363 {
364 Context* context = cast<Context*>(parsingData->GetContext(Id()));
365 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
366 }
367 public void PostConditionalExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
368 {
369 Context* context = cast<Context*>(parsingData->GetContext(Id()));
370 if (matched)
371 {
372 UniquePtr<Object> fromConditionalExpression_value = stack.Pop();
373 context->fromConditionalExpression = *cast<ValueObject<Node*>*>(fromConditionalExpression_value.Get());
374 }
375 }
376 public class Context : System.Text.Parsing.Context
377 {
378 public Context() : ctx(), value(), fromConditionalExpression()
379 {
380 }
381 public ParsingContext* ctx;
382 public Node* value;
383 public Node* fromConditionalExpression;
384 }
385 }
386
387 public class AssignmentExpressionRule : System.Text.Parsing.RuleParser
388 {
389 public AssignmentExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
390 {
391 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
392 SetValueTypeName(ToUtf32("Node*"));
393 }
394 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
395 {
396 parsingData->PushContext(Id(), new Context());
397 Context* context = cast<Context*>(parsingData->GetContext(Id()));
398 UniquePtr<Object> ctx_value = stack.Pop();
399 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
400 }
401 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
402 {
403 Context* context = cast<Context*>(parsingData->GetContext(Id()));
404 if (matched)
405 {
406 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
407 }
408 parsingData->PopContext(Id());
409 }
410 public override void Link()
411 {
412 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
413 a0ActionParser->SetAction(A0Action);
414 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
415 a1ActionParser->SetAction(A1Action);
416 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
417 a2ActionParser->SetAction(A2Action);
418 NonterminalParser* concreteAssignmentExpressionNonterminalParser = GetNonterminal(ToUtf32("ConcreteAssignmentExpression"));
419 concreteAssignmentExpressionNonterminalParser->SetPre(PreConcreteAssignmentExpression);
420 concreteAssignmentExpressionNonterminalParser->SetPost(PostConcreteAssignmentExpression);
421 NonterminalParser* conditionalExpressionNonterminalParser = GetNonterminal(ToUtf32("ConditionalExpression"));
422 conditionalExpressionNonterminalParser->SetPre(PreConditionalExpression);
423 conditionalExpressionNonterminalParser->SetPost(PostConditionalExpression);
424 NonterminalParser* throwExpressionNonterminalParser = GetNonterminal(ToUtf32("ThrowExpression"));
425 throwExpressionNonterminalParser->SetPre(PreThrowExpression);
426 throwExpressionNonterminalParser->SetPost(PostThrowExpression);
427 }
428 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
429 {
430 Context* context = cast<Context*>(parsingData->GetContext(Id()));
431 context->value = context->fromConcreteAssignmentExpression;
432 }
433 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
434 {
435 Context* context = cast<Context*>(parsingData->GetContext(Id()));
436 context->value = context->fromConditionalExpression;
437 }
438 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
439 {
440 Context* context = cast<Context*>(parsingData->GetContext(Id()));
441 context->value = context->fromThrowExpression;
442 }
443 public void PreConcreteAssignmentExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
444 {
445 Context* context = cast<Context*>(parsingData->GetContext(Id()));
446 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
447 }
448 public void PostConcreteAssignmentExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
449 {
450 Context* context = cast<Context*>(parsingData->GetContext(Id()));
451 if (matched)
452 {
453 UniquePtr<Object> fromConcreteAssignmentExpression_value = stack.Pop();
454 context->fromConcreteAssignmentExpression = *cast<ValueObject<Node*>*>(fromConcreteAssignmentExpression_value.Get());
455 }
456 }
457 public void PreConditionalExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
458 {
459 Context* context = cast<Context*>(parsingData->GetContext(Id()));
460 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
461 }
462 public void PostConditionalExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
463 {
464 Context* context = cast<Context*>(parsingData->GetContext(Id()));
465 if (matched)
466 {
467 UniquePtr<Object> fromConditionalExpression_value = stack.Pop();
468 context->fromConditionalExpression = *cast<ValueObject<Node*>*>(fromConditionalExpression_value.Get());
469 }
470 }
471 public void PreThrowExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
472 {
473 Context* context = cast<Context*>(parsingData->GetContext(Id()));
474 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
475 }
476 public void PostThrowExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
477 {
478 Context* context = cast<Context*>(parsingData->GetContext(Id()));
479 if (matched)
480 {
481 UniquePtr<Object> fromThrowExpression_value = stack.Pop();
482 context->fromThrowExpression = *cast<ValueObject<Node*>*>(fromThrowExpression_value.Get());
483 }
484 }
485 public class Context : System.Text.Parsing.Context
486 {
487 public Context() : ctx(), value(), fromConcreteAssignmentExpression(), fromConditionalExpression(), fromThrowExpression()
488 {
489 }
490 public ParsingContext* ctx;
491 public Node* value;
492 public Node* fromConcreteAssignmentExpression;
493 public Node* fromConditionalExpression;
494 public Node* fromThrowExpression;
495 }
496 }
497
498 public class ConcreteAssignmentExpressionRule : System.Text.Parsing.RuleParser
499 {
500 public ConcreteAssignmentExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
501 {
502 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
503 SetValueTypeName(ToUtf32("Node*"));
504 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
505 }
506 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
507 {
508 parsingData->PushContext(Id(), new Context());
509 Context* context = cast<Context*>(parsingData->GetContext(Id()));
510 UniquePtr<Object> ctx_value = stack.Pop();
511 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
512 }
513 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
514 {
515 Context* context = cast<Context*>(parsingData->GetContext(Id()));
516 if (matched)
517 {
518 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
519 }
520 parsingData->PopContext(Id());
521 }
522 public override void Link()
523 {
524 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
525 a0ActionParser->SetAction(A0Action);
526 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
527 a1ActionParser->SetAction(A1Action);
528 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
529 a2ActionParser->SetAction(A2Action);
530 a2ActionParser->SetFailure(A2ActionFail);
531 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
532 a3ActionParser->SetAction(A3Action);
533 NonterminalParser* logicalOrExpressionNonterminalParser = GetNonterminal(ToUtf32("LogicalOrExpression"));
534 logicalOrExpressionNonterminalParser->SetPre(PreLogicalOrExpression);
535 logicalOrExpressionNonterminalParser->SetPost(PostLogicalOrExpression);
536 NonterminalParser* assignmentOperatorNonterminalParser = GetNonterminal(ToUtf32("AssignmentOperator"));
537 assignmentOperatorNonterminalParser->SetPost(PostAssignmentOperator);
538 NonterminalParser* initializerClauseNonterminalParser = GetNonterminal(ToUtf32("InitializerClause"));
539 initializerClauseNonterminalParser->SetPre(PreInitializerClause);
540 initializerClauseNonterminalParser->SetPost(PostInitializerClause);
541 }
542 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
543 {
544 Context* context = cast<Context*>(parsingData->GetContext(Id()));
545 context->ctx->BeginParsingLvalue();
546 }
547 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
548 {
549 Context* context = cast<Context*>(parsingData->GetContext(Id()));
550 context->value = context->node.Release();
551 }
552 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
553 {
554 Context* context = cast<Context*>(parsingData->GetContext(Id()));
555 context->node.Reset(context->fromLogicalOrExpression);
556 context->ctx->EndParsingLvalue();
557 }
558 public void A2ActionFail(ParsingData* parsingData)
559 {
560 Context* context = cast<Context*>(parsingData->GetContext(Id()));
561 context->ctx->EndParsingLvalue();
562 }
563 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
564 {
565 Context* context = cast<Context*>(parsingData->GetContext(Id()));
566 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromInitializerClause, context->fromAssignmentOperator));
567 }
568 public void PreLogicalOrExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
569 {
570 Context* context = cast<Context*>(parsingData->GetContext(Id()));
571 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
572 }
573 public void PostLogicalOrExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
574 {
575 Context* context = cast<Context*>(parsingData->GetContext(Id()));
576 if (matched)
577 {
578 UniquePtr<Object> fromLogicalOrExpression_value = stack.Pop();
579 context->fromLogicalOrExpression = *cast<ValueObject<Node*>*>(fromLogicalOrExpression_value.Get());
580 }
581 }
582 public void PostAssignmentOperator(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
583 {
584 Context* context = cast<Context*>(parsingData->GetContext(Id()));
585 if (matched)
586 {
587 UniquePtr<Object> fromAssignmentOperator_value = stack.Pop();
588 context->fromAssignmentOperator = *cast<ValueObject<Operator>*>(fromAssignmentOperator_value.Get());
589 }
590 }
591 public void PreInitializerClause(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
592 {
593 Context* context = cast<Context*>(parsingData->GetContext(Id()));
594 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
595 }
596 public void PostInitializerClause(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
597 {
598 Context* context = cast<Context*>(parsingData->GetContext(Id()));
599 if (matched)
600 {
601 UniquePtr<Object> fromInitializerClause_value = stack.Pop();
602 context->fromInitializerClause = *cast<ValueObject<Node*>*>(fromInitializerClause_value.Get());
603 }
604 }
605 public class Context : System.Text.Parsing.Context
606 {
607 public Context() : ctx(), value(), node(), fromLogicalOrExpression(), fromAssignmentOperator(), fromInitializerClause()
608 {
609 }
610 public ParsingContext* ctx;
611 public Node* value;
612 public UniquePtr<Node> node;
613 public Node* fromLogicalOrExpression;
614 public Operator fromAssignmentOperator;
615 public Node* fromInitializerClause;
616 }
617 }
618
619 public class AssignmentOperatorRule : System.Text.Parsing.RuleParser
620 {
621 public AssignmentOperatorRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
622 {
623 SetValueTypeName(ToUtf32("Operator"));
624 }
625 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
626 {
627 parsingData->PushContext(Id(), new Context());
628 Context* context = cast<Context*>(parsingData->GetContext(Id()));
629 }
630 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
631 {
632 Context* context = cast<Context*>(parsingData->GetContext(Id()));
633 if (matched)
634 {
635 stack.Push(UniquePtr<Object>(new ValueObject<Operator>(context->value)));
636 }
637 parsingData->PopContext(Id());
638 }
639 public override void Link()
640 {
641 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
642 a0ActionParser->SetAction(A0Action);
643 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
644 a1ActionParser->SetAction(A1Action);
645 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
646 a2ActionParser->SetAction(A2Action);
647 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
648 a3ActionParser->SetAction(A3Action);
649 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
650 a4ActionParser->SetAction(A4Action);
651 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
652 a5ActionParser->SetAction(A5Action);
653 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
654 a6ActionParser->SetAction(A6Action);
655 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
656 a7ActionParser->SetAction(A7Action);
657 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
658 a8ActionParser->SetAction(A8Action);
659 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
660 a9ActionParser->SetAction(A9Action);
661 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
662 a10ActionParser->SetAction(A10Action);
663 }
664 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
665 {
666 Context* context = cast<Context*>(parsingData->GetContext(Id()));
667 context->value = Operator.assign;
668 }
669 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
670 {
671 Context* context = cast<Context*>(parsingData->GetContext(Id()));
672 context->value = Operator.mulAssign;
673 }
674 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
675 {
676 Context* context = cast<Context*>(parsingData->GetContext(Id()));
677 context->value = Operator.divAssign;
678 }
679 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
680 {
681 Context* context = cast<Context*>(parsingData->GetContext(Id()));
682 context->value = Operator.remAssign;
683 }
684 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
685 {
686 Context* context = cast<Context*>(parsingData->GetContext(Id()));
687 context->value = Operator.addAssign;
688 }
689 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
690 {
691 Context* context = cast<Context*>(parsingData->GetContext(Id()));
692 context->value = Operator.subAssign;
693 }
694 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
695 {
696 Context* context = cast<Context*>(parsingData->GetContext(Id()));
697 context->value = Operator.shiftRightAssign;
698 }
699 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
700 {
701 Context* context = cast<Context*>(parsingData->GetContext(Id()));
702 context->value = Operator.shiftLeftAssign;
703 }
704 public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
705 {
706 Context* context = cast<Context*>(parsingData->GetContext(Id()));
707 context->value = Operator.andAssign;
708 }
709 public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
710 {
711 Context* context = cast<Context*>(parsingData->GetContext(Id()));
712 context->value = Operator.xorAssign;
713 }
714 public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
715 {
716 Context* context = cast<Context*>(parsingData->GetContext(Id()));
717 context->value = Operator.orAssign;
718 }
719 public class Context : System.Text.Parsing.Context
720 {
721 public Context() : value()
722 {
723 }
724 public Operator value;
725 }
726 }
727
728 public class ConditionalExpressionRule : System.Text.Parsing.RuleParser
729 {
730 public ConditionalExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
731 {
732 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
733 SetValueTypeName(ToUtf32("Node*"));
734 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
735 }
736 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
737 {
738 parsingData->PushContext(Id(), new Context());
739 Context* context = cast<Context*>(parsingData->GetContext(Id()));
740 UniquePtr<Object> ctx_value = stack.Pop();
741 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
742 }
743 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
744 {
745 Context* context = cast<Context*>(parsingData->GetContext(Id()));
746 if (matched)
747 {
748 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
749 }
750 parsingData->PopContext(Id());
751 }
752 public override void Link()
753 {
754 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
755 a0ActionParser->SetAction(A0Action);
756 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
757 a1ActionParser->SetAction(A1Action);
758 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
759 a2ActionParser->SetAction(A2Action);
760 NonterminalParser* logicalOrExpressionNonterminalParser = GetNonterminal(ToUtf32("LogicalOrExpression"));
761 logicalOrExpressionNonterminalParser->SetPre(PreLogicalOrExpression);
762 logicalOrExpressionNonterminalParser->SetPost(PostLogicalOrExpression);
763 NonterminalParser* expressionNonterminalParser = GetNonterminal(ToUtf32("Expression"));
764 expressionNonterminalParser->SetPre(PreExpression);
765 expressionNonterminalParser->SetPost(PostExpression);
766 NonterminalParser* assignmentExpressionNonterminalParser = GetNonterminal(ToUtf32("AssignmentExpression"));
767 assignmentExpressionNonterminalParser->SetPre(PreAssignmentExpression);
768 assignmentExpressionNonterminalParser->SetPost(PostAssignmentExpression);
769 }
770 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
771 {
772 Context* context = cast<Context*>(parsingData->GetContext(Id()));
773 context->value = context->node.Release();
774 }
775 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
776 {
777 Context* context = cast<Context*>(parsingData->GetContext(Id()));
778 context->node.Reset(context->fromLogicalOrExpression);
779 }
780 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
781 {
782 Context* context = cast<Context*>(parsingData->GetContext(Id()));
783 context->node.Reset(new ConditionalExpressionNode(span, context->node.Release(), context->fromExpression, context->fromAssignmentExpression));
784 }
785 public void PreLogicalOrExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
786 {
787 Context* context = cast<Context*>(parsingData->GetContext(Id()));
788 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
789 }
790 public void PostLogicalOrExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
791 {
792 Context* context = cast<Context*>(parsingData->GetContext(Id()));
793 if (matched)
794 {
795 UniquePtr<Object> fromLogicalOrExpression_value = stack.Pop();
796 context->fromLogicalOrExpression = *cast<ValueObject<Node*>*>(fromLogicalOrExpression_value.Get());
797 }
798 }
799 public void PreExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
800 {
801 Context* context = cast<Context*>(parsingData->GetContext(Id()));
802 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
803 }
804 public void PostExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
805 {
806 Context* context = cast<Context*>(parsingData->GetContext(Id()));
807 if (matched)
808 {
809 UniquePtr<Object> fromExpression_value = stack.Pop();
810 context->fromExpression = *cast<ValueObject<Node*>*>(fromExpression_value.Get());
811 }
812 }
813 public void PreAssignmentExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
814 {
815 Context* context = cast<Context*>(parsingData->GetContext(Id()));
816 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
817 }
818 public void PostAssignmentExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
819 {
820 Context* context = cast<Context*>(parsingData->GetContext(Id()));
821 if (matched)
822 {
823 UniquePtr<Object> fromAssignmentExpression_value = stack.Pop();
824 context->fromAssignmentExpression = *cast<ValueObject<Node*>*>(fromAssignmentExpression_value.Get());
825 }
826 }
827 public class Context : System.Text.Parsing.Context
828 {
829 public Context() : ctx(), value(), node(), fromLogicalOrExpression(), fromExpression(), fromAssignmentExpression()
830 {
831 }
832 public ParsingContext* ctx;
833 public Node* value;
834 public UniquePtr<Node> node;
835 public Node* fromLogicalOrExpression;
836 public Node* fromExpression;
837 public Node* fromAssignmentExpression;
838 }
839 }
840
841 public class ThrowExpressionRule : System.Text.Parsing.RuleParser
842 {
843 public ThrowExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
844 {
845 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
846 SetValueTypeName(ToUtf32("Node*"));
847 }
848 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
849 {
850 parsingData->PushContext(Id(), new Context());
851 Context* context = cast<Context*>(parsingData->GetContext(Id()));
852 UniquePtr<Object> ctx_value = stack.Pop();
853 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
854 }
855 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
856 {
857 Context* context = cast<Context*>(parsingData->GetContext(Id()));
858 if (matched)
859 {
860 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
861 }
862 parsingData->PopContext(Id());
863 }
864 public override void Link()
865 {
866 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
867 a0ActionParser->SetAction(A0Action);
868 NonterminalParser* assignmentExpressionNonterminalParser = GetNonterminal(ToUtf32("AssignmentExpression"));
869 assignmentExpressionNonterminalParser->SetPre(PreAssignmentExpression);
870 assignmentExpressionNonterminalParser->SetPost(PostAssignmentExpression);
871 }
872 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
873 {
874 Context* context = cast<Context*>(parsingData->GetContext(Id()));
875 context->value = new ThrowExpressionNode(span, context->fromAssignmentExpression);
876 }
877 public void PreAssignmentExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
878 {
879 Context* context = cast<Context*>(parsingData->GetContext(Id()));
880 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
881 }
882 public void PostAssignmentExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
883 {
884 Context* context = cast<Context*>(parsingData->GetContext(Id()));
885 if (matched)
886 {
887 UniquePtr<Object> fromAssignmentExpression_value = stack.Pop();
888 context->fromAssignmentExpression = *cast<ValueObject<Node*>*>(fromAssignmentExpression_value.Get());
889 }
890 }
891 public class Context : System.Text.Parsing.Context
892 {
893 public Context() : ctx(), value(), fromAssignmentExpression()
894 {
895 }
896 public ParsingContext* ctx;
897 public Node* value;
898 public Node* fromAssignmentExpression;
899 }
900 }
901
902 public class LogicalOrExpressionRule : System.Text.Parsing.RuleParser
903 {
904 public LogicalOrExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
905 {
906 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
907 SetValueTypeName(ToUtf32("Node*"));
908 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
909 }
910 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
911 {
912 parsingData->PushContext(Id(), new Context());
913 Context* context = cast<Context*>(parsingData->GetContext(Id()));
914 UniquePtr<Object> ctx_value = stack.Pop();
915 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
916 }
917 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
918 {
919 Context* context = cast<Context*>(parsingData->GetContext(Id()));
920 if (matched)
921 {
922 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
923 }
924 parsingData->PopContext(Id());
925 }
926 public override void Link()
927 {
928 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
929 a0ActionParser->SetAction(A0Action);
930 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
931 a1ActionParser->SetAction(A1Action);
932 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
933 a2ActionParser->SetAction(A2Action);
934 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
935 a3ActionParser->SetAction(A3Action);
936 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
937 leftNonterminalParser->SetPre(Preleft);
938 leftNonterminalParser->SetPost(Postleft);
939 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
940 rightNonterminalParser->SetPre(Preright);
941 rightNonterminalParser->SetPost(Postright);
942 }
943 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
944 {
945 Context* context = cast<Context*>(parsingData->GetContext(Id()));
946 context->value = context->node.Release();
947 }
948 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
949 {
950 Context* context = cast<Context*>(parsingData->GetContext(Id()));
951 context->node.Reset(context->fromleft);
952 }
953 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
954 {
955 Context* context = cast<Context*>(parsingData->GetContext(Id()));
956 if (context->ctx->ParsingTemplateIdOrLvalueAndNotArguments()) pass = false;
957 }
958 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
959 {
960 Context* context = cast<Context*>(parsingData->GetContext(Id()));
961 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, Operator.logicalOr));
962 }
963 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
964 {
965 Context* context = cast<Context*>(parsingData->GetContext(Id()));
966 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
967 }
968 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
969 {
970 Context* context = cast<Context*>(parsingData->GetContext(Id()));
971 if (matched)
972 {
973 UniquePtr<Object> fromleft_value = stack.Pop();
974 context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
975 }
976 }
977 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
978 {
979 Context* context = cast<Context*>(parsingData->GetContext(Id()));
980 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
981 }
982 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
983 {
984 Context* context = cast<Context*>(parsingData->GetContext(Id()));
985 if (matched)
986 {
987 UniquePtr<Object> fromright_value = stack.Pop();
988 context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
989 }
990 }
991 public class Context : System.Text.Parsing.Context
992 {
993 public Context() : ctx(), value(), node(), fromleft(), fromright()
994 {
995 }
996 public ParsingContext* ctx;
997 public Node* value;
998 public UniquePtr<Node> node;
999 public Node* fromleft;
1000 public Node* fromright;
1001 }
1002 }
1003
1004 public class LogicalAndExpressionRule : System.Text.Parsing.RuleParser
1005 {
1006 public LogicalAndExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1007 {
1008 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1009 SetValueTypeName(ToUtf32("Node*"));
1010 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1011 }
1012 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1013 {
1014 parsingData->PushContext(Id(), new Context());
1015 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1016 UniquePtr<Object> ctx_value = stack.Pop();
1017 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1018 }
1019 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1020 {
1021 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1022 if (matched)
1023 {
1024 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1025 }
1026 parsingData->PopContext(Id());
1027 }
1028 public override void Link()
1029 {
1030 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1031 a0ActionParser->SetAction(A0Action);
1032 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1033 a1ActionParser->SetAction(A1Action);
1034 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1035 a2ActionParser->SetAction(A2Action);
1036 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1037 a3ActionParser->SetAction(A3Action);
1038 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1039 leftNonterminalParser->SetPre(Preleft);
1040 leftNonterminalParser->SetPost(Postleft);
1041 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1042 rightNonterminalParser->SetPre(Preright);
1043 rightNonterminalParser->SetPost(Postright);
1044 }
1045 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1046 {
1047 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1048 context->value = context->node.Release();
1049 }
1050 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1051 {
1052 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1053 context->node.Reset(context->fromleft);
1054 }
1055 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1056 {
1057 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1058 if (context->ctx->ParsingTemplateIdOrLvalueAndNotArguments()) pass = false;
1059 }
1060 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1061 {
1062 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1063 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, Operator.logicalAnd));
1064 }
1065 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1066 {
1067 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1068 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1069 }
1070 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1071 {
1072 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1073 if (matched)
1074 {
1075 UniquePtr<Object> fromleft_value = stack.Pop();
1076 context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1077 }
1078 }
1079 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1080 {
1081 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1082 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1083 }
1084 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1085 {
1086 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1087 if (matched)
1088 {
1089 UniquePtr<Object> fromright_value = stack.Pop();
1090 context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1091 }
1092 }
1093 public class Context : System.Text.Parsing.Context
1094 {
1095 public Context() : ctx(), value(), node(), fromleft(), fromright()
1096 {
1097 }
1098 public ParsingContext* ctx;
1099 public Node* value;
1100 public UniquePtr<Node> node;
1101 public Node* fromleft;
1102 public Node* fromright;
1103 }
1104 }
1105
1106 public class InclusiveOrExpressionRule : System.Text.Parsing.RuleParser
1107 {
1108 public InclusiveOrExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1109 {
1110 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1111 SetValueTypeName(ToUtf32("Node*"));
1112 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1113 }
1114 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1115 {
1116 parsingData->PushContext(Id(), new Context());
1117 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1118 UniquePtr<Object> ctx_value = stack.Pop();
1119 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1120 }
1121 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1122 {
1123 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1124 if (matched)
1125 {
1126 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1127 }
1128 parsingData->PopContext(Id());
1129 }
1130 public override void Link()
1131 {
1132 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1133 a0ActionParser->SetAction(A0Action);
1134 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1135 a1ActionParser->SetAction(A1Action);
1136 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1137 a2ActionParser->SetAction(A2Action);
1138 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1139 a3ActionParser->SetAction(A3Action);
1140 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1141 leftNonterminalParser->SetPre(Preleft);
1142 leftNonterminalParser->SetPost(Postleft);
1143 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1144 rightNonterminalParser->SetPre(Preright);
1145 rightNonterminalParser->SetPost(Postright);
1146 }
1147 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1148 {
1149 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1150 context->value = context->node.Release();
1151 }
1152 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1153 {
1154 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1155 context->node.Reset(context->fromleft);
1156 }
1157 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1158 {
1159 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1160 if (context->ctx->ParsingLvalueAndNotArguments()) pass = false;
1161 }
1162 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1163 {
1164 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1165 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, Operator.or_));
1166 }
1167 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1168 {
1169 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1170 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1171 }
1172 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1173 {
1174 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1175 if (matched)
1176 {
1177 UniquePtr<Object> fromleft_value = stack.Pop();
1178 context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1179 }
1180 }
1181 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1182 {
1183 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1184 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1185 }
1186 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1187 {
1188 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1189 if (matched)
1190 {
1191 UniquePtr<Object> fromright_value = stack.Pop();
1192 context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1193 }
1194 }
1195 public class Context : System.Text.Parsing.Context
1196 {
1197 public Context() : ctx(), value(), node(), fromleft(), fromright()
1198 {
1199 }
1200 public ParsingContext* ctx;
1201 public Node* value;
1202 public UniquePtr<Node> node;
1203 public Node* fromleft;
1204 public Node* fromright;
1205 }
1206 }
1207
1208 public class ExclusiveOrExpressionRule : System.Text.Parsing.RuleParser
1209 {
1210 public ExclusiveOrExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1211 {
1212 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1213 SetValueTypeName(ToUtf32("Node*"));
1214 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1215 }
1216 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1217 {
1218 parsingData->PushContext(Id(), new Context());
1219 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1220 UniquePtr<Object> ctx_value = stack.Pop();
1221 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1222 }
1223 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1224 {
1225 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1226 if (matched)
1227 {
1228 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1229 }
1230 parsingData->PopContext(Id());
1231 }
1232 public override void Link()
1233 {
1234 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1235 a0ActionParser->SetAction(A0Action);
1236 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1237 a1ActionParser->SetAction(A1Action);
1238 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1239 a2ActionParser->SetAction(A2Action);
1240 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1241 a3ActionParser->SetAction(A3Action);
1242 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1243 leftNonterminalParser->SetPre(Preleft);
1244 leftNonterminalParser->SetPost(Postleft);
1245 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1246 rightNonterminalParser->SetPre(Preright);
1247 rightNonterminalParser->SetPost(Postright);
1248 }
1249 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1250 {
1251 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1252 context->value = context->node.Release();
1253 }
1254 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1255 {
1256 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1257 context->node.Reset(context->fromleft);
1258 }
1259 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1260 {
1261 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1262 if (context->ctx->ParsingLvalueAndNotArguments()) pass = false;
1263 }
1264 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1265 {
1266 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1267 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, Operator.xor));
1268 }
1269 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1270 {
1271 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1272 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1273 }
1274 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1275 {
1276 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1277 if (matched)
1278 {
1279 UniquePtr<Object> fromleft_value = stack.Pop();
1280 context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1281 }
1282 }
1283 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1284 {
1285 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1286 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1287 }
1288 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1289 {
1290 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1291 if (matched)
1292 {
1293 UniquePtr<Object> fromright_value = stack.Pop();
1294 context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1295 }
1296 }
1297 public class Context : System.Text.Parsing.Context
1298 {
1299 public Context() : ctx(), value(), node(), fromleft(), fromright()
1300 {
1301 }
1302 public ParsingContext* ctx;
1303 public Node* value;
1304 public UniquePtr<Node> node;
1305 public Node* fromleft;
1306 public Node* fromright;
1307 }
1308 }
1309
1310 public class AndExpressionRule : System.Text.Parsing.RuleParser
1311 {
1312 public AndExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1313 {
1314 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1315 SetValueTypeName(ToUtf32("Node*"));
1316 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1317 }
1318 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1319 {
1320 parsingData->PushContext(Id(), new Context());
1321 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1322 UniquePtr<Object> ctx_value = stack.Pop();
1323 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1324 }
1325 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1326 {
1327 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1328 if (matched)
1329 {
1330 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1331 }
1332 parsingData->PopContext(Id());
1333 }
1334 public override void Link()
1335 {
1336 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1337 a0ActionParser->SetAction(A0Action);
1338 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1339 a1ActionParser->SetAction(A1Action);
1340 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1341 a2ActionParser->SetAction(A2Action);
1342 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1343 a3ActionParser->SetAction(A3Action);
1344 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1345 leftNonterminalParser->SetPre(Preleft);
1346 leftNonterminalParser->SetPost(Postleft);
1347 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1348 rightNonterminalParser->SetPre(Preright);
1349 rightNonterminalParser->SetPost(Postright);
1350 }
1351 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1352 {
1353 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1354 context->value = context->node.Release();
1355 }
1356 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1357 {
1358 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1359 context->node.Reset(context->fromleft);
1360 }
1361 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1362 {
1363 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1364 if (context->ctx->ParsingLvalueAndNotArguments()) pass = false;
1365 }
1366 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1367 {
1368 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1369 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, Operator.and_));
1370 }
1371 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1372 {
1373 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1374 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1375 }
1376 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1377 {
1378 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1379 if (matched)
1380 {
1381 UniquePtr<Object> fromleft_value = stack.Pop();
1382 context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1383 }
1384 }
1385 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1386 {
1387 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1388 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1389 }
1390 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1391 {
1392 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1393 if (matched)
1394 {
1395 UniquePtr<Object> fromright_value = stack.Pop();
1396 context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1397 }
1398 }
1399 public class Context : System.Text.Parsing.Context
1400 {
1401 public Context() : ctx(), value(), node(), fromleft(), fromright()
1402 {
1403 }
1404 public ParsingContext* ctx;
1405 public Node* value;
1406 public UniquePtr<Node> node;
1407 public Node* fromleft;
1408 public Node* fromright;
1409 }
1410 }
1411
1412 public class EqualityExpressionRule : System.Text.Parsing.RuleParser
1413 {
1414 public EqualityExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1415 {
1416 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1417 SetValueTypeName(ToUtf32("Node*"));
1418 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1419 AddLocalVariable(AttrOrVar(ToUtf32("Operator"), ToUtf32("op")));
1420 }
1421 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1422 {
1423 parsingData->PushContext(Id(), new Context());
1424 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1425 UniquePtr<Object> ctx_value = stack.Pop();
1426 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1427 }
1428 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1429 {
1430 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1431 if (matched)
1432 {
1433 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1434 }
1435 parsingData->PopContext(Id());
1436 }
1437 public override void Link()
1438 {
1439 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1440 a0ActionParser->SetAction(A0Action);
1441 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1442 a1ActionParser->SetAction(A1Action);
1443 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1444 a2ActionParser->SetAction(A2Action);
1445 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1446 a3ActionParser->SetAction(A3Action);
1447 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
1448 a4ActionParser->SetAction(A4Action);
1449 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
1450 a5ActionParser->SetAction(A5Action);
1451 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1452 leftNonterminalParser->SetPre(Preleft);
1453 leftNonterminalParser->SetPost(Postleft);
1454 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1455 rightNonterminalParser->SetPre(Preright);
1456 rightNonterminalParser->SetPost(Postright);
1457 }
1458 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1459 {
1460 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1461 context->value = context->node.Release();
1462 }
1463 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1464 {
1465 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1466 context->node.Reset(context->fromleft);
1467 }
1468 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1469 {
1470 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1471 if (context->ctx->ParsingLvalueAndNotArguments()) pass = false;
1472 }
1473 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1474 {
1475 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1476 context->op = Operator.equal;
1477 }
1478 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1479 {
1480 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1481 context->op = Operator.notEqual;
1482 }
1483 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1484 {
1485 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1486 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, context->op));
1487 }
1488 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1489 {
1490 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1491 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1492 }
1493 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1494 {
1495 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1496 if (matched)
1497 {
1498 UniquePtr<Object> fromleft_value = stack.Pop();
1499 context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1500 }
1501 }
1502 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1503 {
1504 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1505 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1506 }
1507 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1508 {
1509 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1510 if (matched)
1511 {
1512 UniquePtr<Object> fromright_value = stack.Pop();
1513 context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1514 }
1515 }
1516 public class Context : System.Text.Parsing.Context
1517 {
1518 public Context() : ctx(), value(), node(), op(), fromleft(), fromright()
1519 {
1520 }
1521 public ParsingContext* ctx;
1522 public Node* value;
1523 public UniquePtr<Node> node;
1524 public Operator op;
1525 public Node* fromleft;
1526 public Node* fromright;
1527 }
1528 }
1529
1530 public class RelationalExpressionRule : System.Text.Parsing.RuleParser
1531 {
1532 public RelationalExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1533 {
1534 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1535 SetValueTypeName(ToUtf32("Node*"));
1536 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1537 AddLocalVariable(AttrOrVar(ToUtf32("Operator"), ToUtf32("op")));
1538 }
1539 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1540 {
1541 parsingData->PushContext(Id(), new Context());
1542 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1543 UniquePtr<Object> ctx_value = stack.Pop();
1544 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1545 }
1546 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1547 {
1548 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1549 if (matched)
1550 {
1551 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1552 }
1553 parsingData->PopContext(Id());
1554 }
1555 public override void Link()
1556 {
1557 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1558 a0ActionParser->SetAction(A0Action);
1559 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1560 a1ActionParser->SetAction(A1Action);
1561 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1562 a2ActionParser->SetAction(A2Action);
1563 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1564 a3ActionParser->SetAction(A3Action);
1565 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
1566 a4ActionParser->SetAction(A4Action);
1567 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
1568 a5ActionParser->SetAction(A5Action);
1569 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
1570 a6ActionParser->SetAction(A6Action);
1571 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
1572 a7ActionParser->SetAction(A7Action);
1573 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1574 leftNonterminalParser->SetPre(Preleft);
1575 leftNonterminalParser->SetPost(Postleft);
1576 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1577 rightNonterminalParser->SetPre(Preright);
1578 rightNonterminalParser->SetPost(Postright);
1579 }
1580 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1581 {
1582 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1583 context->value = context->node.Release();
1584 }
1585 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1586 {
1587 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1588 context->node.Reset(context->fromleft);
1589 }
1590 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1591 {
1592 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1593 if (context->ctx->ParsingTemplateIdOrLvalueAndNotArguments()) pass = false;
1594 }
1595 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1596 {
1597 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1598 context->op = Operator.lessOrEqual;
1599 }
1600 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1601 {
1602 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1603 context->op = Operator.greaterOrEqual;
1604 }
1605 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1606 {
1607 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1608 context->op = Operator.less;
1609 }
1610 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1611 {
1612 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1613 context->op = Operator.greater;
1614 }
1615 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1616 {
1617 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1618 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, context->op));
1619 }
1620 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1621 {
1622 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1623 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1624 }
1625 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1626 {
1627 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1628 if (matched)
1629 {
1630 UniquePtr<Object> fromleft_value = stack.Pop();
1631 context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1632 }
1633 }
1634 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1635 {
1636 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1637 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1638 }
1639 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1640 {
1641 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1642 if (matched)
1643 {
1644 UniquePtr<Object> fromright_value = stack.Pop();
1645 context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1646 }
1647 }
1648 public class Context : System.Text.Parsing.Context
1649 {
1650 public Context() : ctx(), value(), node(), op(), fromleft(), fromright()
1651 {
1652 }
1653 public ParsingContext* ctx;
1654 public Node* value;
1655 public UniquePtr<Node> node;
1656 public Operator op;
1657 public Node* fromleft;
1658 public Node* fromright;
1659 }
1660 }
1661
1662 public class ShiftExpressionRule : System.Text.Parsing.RuleParser
1663 {
1664 public ShiftExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1665 {
1666 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1667 SetValueTypeName(ToUtf32("Node*"));
1668 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1669 AddLocalVariable(AttrOrVar(ToUtf32("Operator"), ToUtf32("op")));
1670 }
1671 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1672 {
1673 parsingData->PushContext(Id(), new Context());
1674 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1675 UniquePtr<Object> ctx_value = stack.Pop();
1676 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1677 }
1678 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1679 {
1680 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1681 if (matched)
1682 {
1683 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1684 }
1685 parsingData->PopContext(Id());
1686 }
1687 public override void Link()
1688 {
1689 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1690 a0ActionParser->SetAction(A0Action);
1691 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1692 a1ActionParser->SetAction(A1Action);
1693 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1694 a2ActionParser->SetAction(A2Action);
1695 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1696 a3ActionParser->SetAction(A3Action);
1697 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
1698 a4ActionParser->SetAction(A4Action);
1699 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
1700 a5ActionParser->SetAction(A5Action);
1701 a5ActionParser->SetFailure(A5ActionFail);
1702 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1703 leftNonterminalParser->SetPre(Preleft);
1704 leftNonterminalParser->SetPost(Postleft);
1705 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1706 rightNonterminalParser->SetPre(Preright);
1707 rightNonterminalParser->SetPost(Postright);
1708 }
1709 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1710 {
1711 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1712 context->value = context->node.Release();
1713 }
1714 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1715 {
1716 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1717 context->node.Reset(context->fromleft);
1718 }
1719 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1720 {
1721 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1722 context->ctx->BeginParsingArguments();
1723 }
1724 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1725 {
1726 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1727 context->op = Operator.shiftLeft;
1728 }
1729 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1730 {
1731 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1732 context->op = Operator.shiftRight;
1733 }
1734 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1735 {
1736 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1737 context->ctx->EndParsingArguments();
1738 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, context->op));
1739 }
1740 public void A5ActionFail(ParsingData* parsingData)
1741 {
1742 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1743 context->ctx->EndParsingArguments();
1744 }
1745 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1746 {
1747 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1748 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1749 }
1750 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1751 {
1752 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1753 if (matched)
1754 {
1755 UniquePtr<Object> fromleft_value = stack.Pop();
1756 context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1757 }
1758 }
1759 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1760 {
1761 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1762 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1763 }
1764 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1765 {
1766 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1767 if (matched)
1768 {
1769 UniquePtr<Object> fromright_value = stack.Pop();
1770 context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1771 }
1772 }
1773 public class Context : System.Text.Parsing.Context
1774 {
1775 public Context() : ctx(), value(), node(), op(), fromleft(), fromright()
1776 {
1777 }
1778 public ParsingContext* ctx;
1779 public Node* value;
1780 public UniquePtr<Node> node;
1781 public Operator op;
1782 public Node* fromleft;
1783 public Node* fromright;
1784 }
1785 }
1786
1787 public class AdditiveExpressionRule : System.Text.Parsing.RuleParser
1788 {
1789 public AdditiveExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1790 {
1791 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1792 SetValueTypeName(ToUtf32("Node*"));
1793 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1794 AddLocalVariable(AttrOrVar(ToUtf32("Operator"), ToUtf32("op")));
1795 }
1796 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1797 {
1798 parsingData->PushContext(Id(), new Context());
1799 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1800 UniquePtr<Object> ctx_value = stack.Pop();
1801 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1802 }
1803 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1804 {
1805 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1806 if (matched)
1807 {
1808 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1809 }
1810 parsingData->PopContext(Id());
1811 }
1812 public override void Link()
1813 {
1814 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1815 a0ActionParser->SetAction(A0Action);
1816 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1817 a1ActionParser->SetAction(A1Action);
1818 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1819 a2ActionParser->SetAction(A2Action);
1820 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1821 a3ActionParser->SetAction(A3Action);
1822 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
1823 a4ActionParser->SetAction(A4Action);
1824 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
1825 a5ActionParser->SetAction(A5Action);
1826 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1827 leftNonterminalParser->SetPre(Preleft);
1828 leftNonterminalParser->SetPost(Postleft);
1829 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1830 rightNonterminalParser->SetPre(Preright);
1831 rightNonterminalParser->SetPost(Postright);
1832 }
1833 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1834 {
1835 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1836 context->value = context->node.Release();
1837 }
1838 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1839 {
1840 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1841 context->node.Reset(context->fromleft);
1842 }
1843 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1844 {
1845 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1846 if (context->ctx->ParsingLvalueAndNotArguments()) pass = false;
1847 }
1848 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1849 {
1850 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1851 context->op = Operator.add;
1852 }
1853 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1854 {
1855 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1856 context->op = Operator.sub;
1857 }
1858 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1859 {
1860 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1861 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, context->op));
1862 }
1863 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1864 {
1865 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1866 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1867 }
1868 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1869 {
1870 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1871 if (matched)
1872 {
1873 UniquePtr<Object> fromleft_value = stack.Pop();
1874 context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
1875 }
1876 }
1877 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1878 {
1879 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1880 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1881 }
1882 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1883 {
1884 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1885 if (matched)
1886 {
1887 UniquePtr<Object> fromright_value = stack.Pop();
1888 context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
1889 }
1890 }
1891 public class Context : System.Text.Parsing.Context
1892 {
1893 public Context() : ctx(), value(), node(), op(), fromleft(), fromright()
1894 {
1895 }
1896 public ParsingContext* ctx;
1897 public Node* value;
1898 public UniquePtr<Node> node;
1899 public Operator op;
1900 public Node* fromleft;
1901 public Node* fromright;
1902 }
1903 }
1904
1905 public class MultiplicativeExpressionRule : System.Text.Parsing.RuleParser
1906 {
1907 public MultiplicativeExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1908 {
1909 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
1910 SetValueTypeName(ToUtf32("Node*"));
1911 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
1912 AddLocalVariable(AttrOrVar(ToUtf32("Operator"), ToUtf32("op")));
1913 }
1914 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1915 {
1916 parsingData->PushContext(Id(), new Context());
1917 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1918 UniquePtr<Object> ctx_value = stack.Pop();
1919 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
1920 }
1921 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1922 {
1923 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1924 if (matched)
1925 {
1926 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
1927 }
1928 parsingData->PopContext(Id());
1929 }
1930 public override void Link()
1931 {
1932 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1933 a0ActionParser->SetAction(A0Action);
1934 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1935 a1ActionParser->SetAction(A1Action);
1936 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1937 a2ActionParser->SetAction(A2Action);
1938 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1939 a3ActionParser->SetAction(A3Action);
1940 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
1941 a4ActionParser->SetAction(A4Action);
1942 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
1943 a5ActionParser->SetAction(A5Action);
1944 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
1945 a6ActionParser->SetAction(A6Action);
1946 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
1947 leftNonterminalParser->SetPre(Preleft);
1948 leftNonterminalParser->SetPost(Postleft);
1949 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
1950 rightNonterminalParser->SetPre(Preright);
1951 rightNonterminalParser->SetPost(Postright);
1952 }
1953 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1954 {
1955 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1956 context->value = context->node.Release();
1957 }
1958 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1959 {
1960 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1961 context->node.Reset(context->fromleft);
1962 }
1963 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1964 {
1965 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1966 if (context->ctx->ParsingLvalueAndNotArguments()) pass = false;
1967 }
1968 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1969 {
1970 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1971 context->op = Operator.mul;
1972 }
1973 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1974 {
1975 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1976 context->op = Operator.div;
1977 }
1978 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1979 {
1980 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1981 context->op = Operator.rem;
1982 }
1983 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1984 {
1985 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1986 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, context->op));
1987 }
1988 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1989 {
1990 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1991 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
1992 }
1993 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1994 {
1995 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1996 if (matched)
1997 {
1998 UniquePtr<Object> fromleft_value = stack.Pop();
1999 context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
2000 }
2001 }
2002 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2003 {
2004 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2005 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2006 }
2007 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2008 {
2009 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2010 if (matched)
2011 {
2012 UniquePtr<Object> fromright_value = stack.Pop();
2013 context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
2014 }
2015 }
2016 public class Context : System.Text.Parsing.Context
2017 {
2018 public Context() : ctx(), value(), node(), op(), fromleft(), fromright()
2019 {
2020 }
2021 public ParsingContext* ctx;
2022 public Node* value;
2023 public UniquePtr<Node> node;
2024 public Operator op;
2025 public Node* fromleft;
2026 public Node* fromright;
2027 }
2028 }
2029
2030 public class PMExpressionRule : System.Text.Parsing.RuleParser
2031 {
2032 public PMExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2033 {
2034 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2035 SetValueTypeName(ToUtf32("Node*"));
2036 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
2037 AddLocalVariable(AttrOrVar(ToUtf32("Operator"), ToUtf32("op")));
2038 }
2039 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2040 {
2041 parsingData->PushContext(Id(), new Context());
2042 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2043 UniquePtr<Object> ctx_value = stack.Pop();
2044 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2045 }
2046 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2047 {
2048 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2049 if (matched)
2050 {
2051 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
2052 }
2053 parsingData->PopContext(Id());
2054 }
2055 public override void Link()
2056 {
2057 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2058 a0ActionParser->SetAction(A0Action);
2059 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2060 a1ActionParser->SetAction(A1Action);
2061 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
2062 a2ActionParser->SetAction(A2Action);
2063 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
2064 a3ActionParser->SetAction(A3Action);
2065 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
2066 a4ActionParser->SetAction(A4Action);
2067 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
2068 leftNonterminalParser->SetPre(Preleft);
2069 leftNonterminalParser->SetPost(Postleft);
2070 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
2071 rightNonterminalParser->SetPre(Preright);
2072 rightNonterminalParser->SetPost(Postright);
2073 }
2074 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2075 {
2076 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2077 context->value = context->node.Release();
2078 }
2079 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2080 {
2081 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2082 context->node.Reset(context->fromleft);
2083 }
2084 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2085 {
2086 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2087 context->op = Operator.dotStar;
2088 }
2089 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2090 {
2091 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2092 context->op = Operator.arrowStar;
2093 }
2094 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2095 {
2096 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2097 context->node.Reset(new BinaryExpressionNode(span, context->node.Release(), context->fromright, context->op));
2098 }
2099 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2100 {
2101 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2102 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2103 }
2104 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2105 {
2106 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2107 if (matched)
2108 {
2109 UniquePtr<Object> fromleft_value = stack.Pop();
2110 context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
2111 }
2112 }
2113 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2114 {
2115 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2116 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2117 }
2118 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2119 {
2120 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2121 if (matched)
2122 {
2123 UniquePtr<Object> fromright_value = stack.Pop();
2124 context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
2125 }
2126 }
2127 public class Context : System.Text.Parsing.Context
2128 {
2129 public Context() : ctx(), value(), node(), op(), fromleft(), fromright()
2130 {
2131 }
2132 public ParsingContext* ctx;
2133 public Node* value;
2134 public UniquePtr<Node> node;
2135 public Operator op;
2136 public Node* fromleft;
2137 public Node* fromright;
2138 }
2139 }
2140
2141 public class CastExpressionRule : System.Text.Parsing.RuleParser
2142 {
2143 public CastExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2144 {
2145 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2146 SetValueTypeName(ToUtf32("Node*"));
2147 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
2148 }
2149 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2150 {
2151 parsingData->PushContext(Id(), new Context());
2152 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2153 UniquePtr<Object> ctx_value = stack.Pop();
2154 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2155 }
2156 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2157 {
2158 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2159 if (matched)
2160 {
2161 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
2162 }
2163 parsingData->PopContext(Id());
2164 }
2165 public override void Link()
2166 {
2167 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2168 a0ActionParser->SetAction(A0Action);
2169 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2170 a1ActionParser->SetAction(A1Action);
2171 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
2172 a2ActionParser->SetAction(A2Action);
2173 NonterminalParser* typeExprNonterminalParser = GetNonterminal(ToUtf32("TypeExpr"));
2174 typeExprNonterminalParser->SetPre(PreTypeExpr);
2175 typeExprNonterminalParser->SetPost(PostTypeExpr);
2176 NonterminalParser* castExpressionNonterminalParser = GetNonterminal(ToUtf32("CastExpression"));
2177 castExpressionNonterminalParser->SetPre(PreCastExpression);
2178 castExpressionNonterminalParser->SetPost(PostCastExpression);
2179 NonterminalParser* unaryExpressionNonterminalParser = GetNonterminal(ToUtf32("UnaryExpression"));
2180 unaryExpressionNonterminalParser->SetPre(PreUnaryExpression);
2181 unaryExpressionNonterminalParser->SetPost(PostUnaryExpression);
2182 }
2183 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2184 {
2185 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2186 context->value = context->node.Release();
2187 }
2188 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2189 {
2190 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2191 context->node.Reset(new CastExpressionNode(span, context->fromTypeExpr, context->fromCastExpression));
2192 }
2193 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2194 {
2195 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2196 context->node.Reset(context->fromUnaryExpression);
2197 }
2198 public void PreTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2199 {
2200 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2201 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2202 }
2203 public void PostTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2204 {
2205 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2206 if (matched)
2207 {
2208 UniquePtr<Object> fromTypeExpr_value = stack.Pop();
2209 context->fromTypeExpr = *cast<ValueObject<Node*>*>(fromTypeExpr_value.Get());
2210 }
2211 }
2212 public void PreCastExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2213 {
2214 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2215 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2216 }
2217 public void PostCastExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2218 {
2219 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2220 if (matched)
2221 {
2222 UniquePtr<Object> fromCastExpression_value = stack.Pop();
2223 context->fromCastExpression = *cast<ValueObject<Node*>*>(fromCastExpression_value.Get());
2224 }
2225 }
2226 public void PreUnaryExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2227 {
2228 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2229 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2230 }
2231 public void PostUnaryExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2232 {
2233 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2234 if (matched)
2235 {
2236 UniquePtr<Object> fromUnaryExpression_value = stack.Pop();
2237 context->fromUnaryExpression = *cast<ValueObject<Node*>*>(fromUnaryExpression_value.Get());
2238 }
2239 }
2240 public class Context : System.Text.Parsing.Context
2241 {
2242 public Context() : ctx(), value(), node(), fromTypeExpr(), fromCastExpression(), fromUnaryExpression()
2243 {
2244 }
2245 public ParsingContext* ctx;
2246 public Node* value;
2247 public UniquePtr<Node> node;
2248 public Node* fromTypeExpr;
2249 public Node* fromCastExpression;
2250 public Node* fromUnaryExpression;
2251 }
2252 }
2253
2254 public class UnaryExpressionRule : System.Text.Parsing.RuleParser
2255 {
2256 public UnaryExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2257 {
2258 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2259 SetValueTypeName(ToUtf32("Node*"));
2260 }
2261 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2262 {
2263 parsingData->PushContext(Id(), new Context());
2264 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2265 UniquePtr<Object> ctx_value = stack.Pop();
2266 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2267 }
2268 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2269 {
2270 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2271 if (matched)
2272 {
2273 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
2274 }
2275 parsingData->PopContext(Id());
2276 }
2277 public override void Link()
2278 {
2279 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2280 a0ActionParser->SetAction(A0Action);
2281 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2282 a1ActionParser->SetAction(A1Action);
2283 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
2284 a2ActionParser->SetAction(A2Action);
2285 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
2286 a3ActionParser->SetAction(A3Action);
2287 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
2288 a4ActionParser->SetAction(A4Action);
2289 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
2290 a5ActionParser->SetAction(A5Action);
2291 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
2292 a6ActionParser->SetAction(A6Action);
2293 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
2294 a7ActionParser->SetAction(A7Action);
2295 NonterminalParser* c1NonterminalParser = GetNonterminal(ToUtf32("c1"));
2296 c1NonterminalParser->SetPre(Prec1);
2297 c1NonterminalParser->SetPost(Postc1);
2298 NonterminalParser* c2NonterminalParser = GetNonterminal(ToUtf32("c2"));
2299 c2NonterminalParser->SetPre(Prec2);
2300 c2NonterminalParser->SetPost(Postc2);
2301 NonterminalParser* opNonterminalParser = GetNonterminal(ToUtf32("op"));
2302 opNonterminalParser->SetPost(Postop);
2303 NonterminalParser* c3NonterminalParser = GetNonterminal(ToUtf32("c3"));
2304 c3NonterminalParser->SetPre(Prec3);
2305 c3NonterminalParser->SetPost(Postc3);
2306 NonterminalParser* u4NonterminalParser = GetNonterminal(ToUtf32("u4"));
2307 u4NonterminalParser->SetPre(Preu4);
2308 u4NonterminalParser->SetPost(Postu4);
2309 NonterminalParser* t5NonterminalParser = GetNonterminal(ToUtf32("t5"));
2310 t5NonterminalParser->SetPre(Pret5);
2311 t5NonterminalParser->SetPost(Postt5);
2312 NonterminalParser* newExpressionNonterminalParser = GetNonterminal(ToUtf32("NewExpression"));
2313 newExpressionNonterminalParser->SetPre(PreNewExpression);
2314 newExpressionNonterminalParser->SetPost(PostNewExpression);
2315 NonterminalParser* deleteExpressionNonterminalParser = GetNonterminal(ToUtf32("DeleteExpression"));
2316 deleteExpressionNonterminalParser->SetPre(PreDeleteExpression);
2317 deleteExpressionNonterminalParser->SetPost(PostDeleteExpression);
2318 NonterminalParser* postfixExpressionNonterminalParser = GetNonterminal(ToUtf32("PostfixExpression"));
2319 postfixExpressionNonterminalParser->SetPre(PrePostfixExpression);
2320 postfixExpressionNonterminalParser->SetPost(PostPostfixExpression);
2321 }
2322 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2323 {
2324 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2325 context->value = new PrefixIncrementNode(span, context->fromc1);
2326 }
2327 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2328 {
2329 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2330 context->value = new PrefixDecrementNode(span, context->fromc2);
2331 }
2332 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2333 {
2334 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2335 context->value = new UnaryExpressionNode(span, context->fromc3, context->fromop);
2336 }
2337 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2338 {
2339 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2340 context->value = new SizeOfExpressionNode(span, context->fromu4);
2341 }
2342 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2343 {
2344 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2345 context->value = new AlignOfExpressionNode(span, context->fromt5);
2346 }
2347 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2348 {
2349 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2350 context->value = context->fromNewExpression;
2351 }
2352 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2353 {
2354 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2355 context->value = context->fromDeleteExpression;
2356 }
2357 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2358 {
2359 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2360 context->value = context->fromPostfixExpression;
2361 }
2362 public void Prec1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2363 {
2364 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2365 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2366 }
2367 public void Postc1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2368 {
2369 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2370 if (matched)
2371 {
2372 UniquePtr<Object> fromc1_value = stack.Pop();
2373 context->fromc1 = *cast<ValueObject<Node*>*>(fromc1_value.Get());
2374 }
2375 }
2376 public void Prec2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2377 {
2378 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2379 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2380 }
2381 public void Postc2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2382 {
2383 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2384 if (matched)
2385 {
2386 UniquePtr<Object> fromc2_value = stack.Pop();
2387 context->fromc2 = *cast<ValueObject<Node*>*>(fromc2_value.Get());
2388 }
2389 }
2390 public void Postop(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2391 {
2392 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2393 if (matched)
2394 {
2395 UniquePtr<Object> fromop_value = stack.Pop();
2396 context->fromop = *cast<ValueObject<Operator>*>(fromop_value.Get());
2397 }
2398 }
2399 public void Prec3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2400 {
2401 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2402 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2403 }
2404 public void Postc3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2405 {
2406 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2407 if (matched)
2408 {
2409 UniquePtr<Object> fromc3_value = stack.Pop();
2410 context->fromc3 = *cast<ValueObject<Node*>*>(fromc3_value.Get());
2411 }
2412 }
2413 public void Preu4(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2414 {
2415 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2416 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2417 }
2418 public void Postu4(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2419 {
2420 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2421 if (matched)
2422 {
2423 UniquePtr<Object> fromu4_value = stack.Pop();
2424 context->fromu4 = *cast<ValueObject<Node*>*>(fromu4_value.Get());
2425 }
2426 }
2427 public void Pret5(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2428 {
2429 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2430 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2431 }
2432 public void Postt5(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2433 {
2434 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2435 if (matched)
2436 {
2437 UniquePtr<Object> fromt5_value = stack.Pop();
2438 context->fromt5 = *cast<ValueObject<Node*>*>(fromt5_value.Get());
2439 }
2440 }
2441 public void PreNewExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2442 {
2443 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2444 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2445 }
2446 public void PostNewExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2447 {
2448 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2449 if (matched)
2450 {
2451 UniquePtr<Object> fromNewExpression_value = stack.Pop();
2452 context->fromNewExpression = *cast<ValueObject<NewExpressionNode*>*>(fromNewExpression_value.Get());
2453 }
2454 }
2455 public void PreDeleteExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2456 {
2457 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2458 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2459 }
2460 public void PostDeleteExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2461 {
2462 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2463 if (matched)
2464 {
2465 UniquePtr<Object> fromDeleteExpression_value = stack.Pop();
2466 context->fromDeleteExpression = *cast<ValueObject<DeleteExpressionNode*>*>(fromDeleteExpression_value.Get());
2467 }
2468 }
2469 public void PrePostfixExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2470 {
2471 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2472 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2473 }
2474 public void PostPostfixExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2475 {
2476 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2477 if (matched)
2478 {
2479 UniquePtr<Object> fromPostfixExpression_value = stack.Pop();
2480 context->fromPostfixExpression = *cast<ValueObject<Node*>*>(fromPostfixExpression_value.Get());
2481 }
2482 }
2483 public class Context : System.Text.Parsing.Context
2484 {
2485 public Context() : ctx(), value(), fromc1(), fromc2(), fromop(), fromc3(), fromu4(), fromt5(), fromNewExpression(), fromDeleteExpression(), fromPostfixExpression()
2486 {
2487 }
2488 public ParsingContext* ctx;
2489 public Node* value;
2490 public Node* fromc1;
2491 public Node* fromc2;
2492 public Operator fromop;
2493 public Node* fromc3;
2494 public Node* fromu4;
2495 public Node* fromt5;
2496 public NewExpressionNode* fromNewExpression;
2497 public DeleteExpressionNode* fromDeleteExpression;
2498 public Node* fromPostfixExpression;
2499 }
2500 }
2501
2502 public class UnaryOperatorRule : System.Text.Parsing.RuleParser
2503 {
2504 public UnaryOperatorRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2505 {
2506 SetValueTypeName(ToUtf32("Operator"));
2507 }
2508 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2509 {
2510 parsingData->PushContext(Id(), new Context());
2511 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2512 }
2513 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2514 {
2515 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2516 if (matched)
2517 {
2518 stack.Push(UniquePtr<Object>(new ValueObject<Operator>(context->value)));
2519 }
2520 parsingData->PopContext(Id());
2521 }
2522 public override void Link()
2523 {
2524 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2525 a0ActionParser->SetAction(A0Action);
2526 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2527 a1ActionParser->SetAction(A1Action);
2528 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
2529 a2ActionParser->SetAction(A2Action);
2530 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
2531 a3ActionParser->SetAction(A3Action);
2532 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
2533 a4ActionParser->SetAction(A4Action);
2534 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
2535 a5ActionParser->SetAction(A5Action);
2536 }
2537 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2538 {
2539 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2540 context->value = Operator.deref;
2541 }
2542 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2543 {
2544 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2545 context->value = Operator.addrOf;
2546 }
2547 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2548 {
2549 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2550 context->value = Operator.unaryPlus;
2551 }
2552 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2553 {
2554 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2555 context->value = Operator.unaryMinus;
2556 }
2557 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2558 {
2559 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2560 context->value = Operator.not_;
2561 }
2562 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2563 {
2564 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2565 context->value = Operator.neg;
2566 }
2567 public class Context : System.Text.Parsing.Context
2568 {
2569 public Context() : value()
2570 {
2571 }
2572 public Operator value;
2573 }
2574 }
2575
2576 public class NewExpressionRule : System.Text.Parsing.RuleParser
2577 {
2578 public NewExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2579 {
2580 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2581 SetValueTypeName(ToUtf32("NewExpressionNode*"));
2582 }
2583 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2584 {
2585 parsingData->PushContext(Id(), new Context());
2586 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2587 UniquePtr<Object> ctx_value = stack.Pop();
2588 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2589 }
2590 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2591 {
2592 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2593 if (matched)
2594 {
2595 stack.Push(UniquePtr<Object>(new ValueObject<NewExpressionNode*>(context->value)));
2596 }
2597 parsingData->PopContext(Id());
2598 }
2599 public override void Link()
2600 {
2601 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2602 a0ActionParser->SetAction(A0Action);
2603 NonterminalParser* newPlacementNonterminalParser = GetNonterminal(ToUtf32("NewPlacement"));
2604 newPlacementNonterminalParser->SetPre(PreNewPlacement);
2605 newPlacementNonterminalParser->SetPost(PostNewPlacement);
2606 NonterminalParser* newTypeIdNonterminalParser = GetNonterminal(ToUtf32("NewTypeId"));
2607 newTypeIdNonterminalParser->SetPre(PreNewTypeId);
2608 newTypeIdNonterminalParser->SetPost(PostNewTypeId);
2609 NonterminalParser* newInitializerNonterminalParser = GetNonterminal(ToUtf32("NewInitializer"));
2610 newInitializerNonterminalParser->SetPre(PreNewInitializer);
2611 newInitializerNonterminalParser->SetPost(PostNewInitializer);
2612 }
2613 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2614 {
2615 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2616 context->value = new NewExpressionNode(span, context->fromNewPlacement, context->fromNewTypeId, context->fromNewInitializer);
2617 }
2618 public void PreNewPlacement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2619 {
2620 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2621 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2622 }
2623 public void PostNewPlacement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2624 {
2625 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2626 if (matched)
2627 {
2628 UniquePtr<Object> fromNewPlacement_value = stack.Pop();
2629 context->fromNewPlacement = *cast<ValueObject<ExpressionListNode*>*>(fromNewPlacement_value.Get());
2630 }
2631 }
2632 public void PreNewTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2633 {
2634 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2635 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2636 }
2637 public void PostNewTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2638 {
2639 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2640 if (matched)
2641 {
2642 UniquePtr<Object> fromNewTypeId_value = stack.Pop();
2643 context->fromNewTypeId = *cast<ValueObject<Node*>*>(fromNewTypeId_value.Get());
2644 }
2645 }
2646 public void PreNewInitializer(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2647 {
2648 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2649 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2650 }
2651 public void PostNewInitializer(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2652 {
2653 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2654 if (matched)
2655 {
2656 UniquePtr<Object> fromNewInitializer_value = stack.Pop();
2657 context->fromNewInitializer = *cast<ValueObject<ExpressionListNode*>*>(fromNewInitializer_value.Get());
2658 }
2659 }
2660 public class Context : System.Text.Parsing.Context
2661 {
2662 public Context() : ctx(), value(), fromNewPlacement(), fromNewTypeId(), fromNewInitializer()
2663 {
2664 }
2665 public ParsingContext* ctx;
2666 public NewExpressionNode* value;
2667 public ExpressionListNode* fromNewPlacement;
2668 public Node* fromNewTypeId;
2669 public ExpressionListNode* fromNewInitializer;
2670 }
2671 }
2672
2673 public class NewPlacementRule : System.Text.Parsing.RuleParser
2674 {
2675 public NewPlacementRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2676 {
2677 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2678 SetValueTypeName(ToUtf32("ExpressionListNode*"));
2679 }
2680 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2681 {
2682 parsingData->PushContext(Id(), new Context());
2683 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2684 UniquePtr<Object> ctx_value = stack.Pop();
2685 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2686 }
2687 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2688 {
2689 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2690 if (matched)
2691 {
2692 stack.Push(UniquePtr<Object>(new ValueObject<ExpressionListNode*>(context->value)));
2693 }
2694 parsingData->PopContext(Id());
2695 }
2696 public override void Link()
2697 {
2698 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2699 a0ActionParser->SetAction(A0Action);
2700 NonterminalParser* expressionListNonterminalParser = GetNonterminal(ToUtf32("ExpressionList"));
2701 expressionListNonterminalParser->SetPre(PreExpressionList);
2702 expressionListNonterminalParser->SetPost(PostExpressionList);
2703 }
2704 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2705 {
2706 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2707 context->value = context->fromExpressionList;
2708 }
2709 public void PreExpressionList(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2710 {
2711 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2712 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2713 }
2714 public void PostExpressionList(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2715 {
2716 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2717 if (matched)
2718 {
2719 UniquePtr<Object> fromExpressionList_value = stack.Pop();
2720 context->fromExpressionList = *cast<ValueObject<ExpressionListNode*>*>(fromExpressionList_value.Get());
2721 }
2722 }
2723 public class Context : System.Text.Parsing.Context
2724 {
2725 public Context() : ctx(), value(), fromExpressionList()
2726 {
2727 }
2728 public ParsingContext* ctx;
2729 public ExpressionListNode* value;
2730 public ExpressionListNode* fromExpressionList;
2731 }
2732 }
2733
2734 public class NewTypeIdRule : System.Text.Parsing.RuleParser
2735 {
2736 public NewTypeIdRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2737 {
2738 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2739 SetValueTypeName(ToUtf32("Node*"));
2740 }
2741 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2742 {
2743 parsingData->PushContext(Id(), new Context());
2744 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2745 UniquePtr<Object> ctx_value = stack.Pop();
2746 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2747 }
2748 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2749 {
2750 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2751 if (matched)
2752 {
2753 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
2754 }
2755 parsingData->PopContext(Id());
2756 }
2757 public override void Link()
2758 {
2759 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2760 a0ActionParser->SetAction(A0Action);
2761 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2762 a1ActionParser->SetAction(A1Action);
2763 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
2764 typeNonterminalParser->SetPre(Pretype);
2765 typeNonterminalParser->SetPost(Posttype);
2766 NonterminalParser* sizeNonterminalParser = GetNonterminal(ToUtf32("size"));
2767 sizeNonterminalParser->SetPre(Presize);
2768 sizeNonterminalParser->SetPost(Postsize);
2769 }
2770 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2771 {
2772 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2773 context->value = context->fromtype;
2774 }
2775 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2776 {
2777 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2778 context->value = new ArrayTypeNode(span, context->fromtype, context->fromsize);
2779 }
2780 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2781 {
2782 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2783 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2784 }
2785 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2786 {
2787 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2788 if (matched)
2789 {
2790 UniquePtr<Object> fromtype_value = stack.Pop();
2791 context->fromtype = *cast<ValueObject<Node*>*>(fromtype_value.Get());
2792 }
2793 }
2794 public void Presize(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2795 {
2796 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2797 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2798 }
2799 public void Postsize(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2800 {
2801 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2802 if (matched)
2803 {
2804 UniquePtr<Object> fromsize_value = stack.Pop();
2805 context->fromsize = *cast<ValueObject<Node*>*>(fromsize_value.Get());
2806 }
2807 }
2808 public class Context : System.Text.Parsing.Context
2809 {
2810 public Context() : ctx(), value(), fromtype(), fromsize()
2811 {
2812 }
2813 public ParsingContext* ctx;
2814 public Node* value;
2815 public Node* fromtype;
2816 public Node* fromsize;
2817 }
2818 }
2819
2820 public class NewDeclaratorRule : System.Text.Parsing.RuleParser
2821 {
2822 public NewDeclaratorRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2823 {
2824 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2825 SetValueTypeName(ToUtf32("Node*"));
2826 }
2827 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2828 {
2829 parsingData->PushContext(Id(), new Context());
2830 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2831 UniquePtr<Object> ctx_value = stack.Pop();
2832 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2833 }
2834 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2835 {
2836 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2837 if (matched)
2838 {
2839 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
2840 }
2841 parsingData->PopContext(Id());
2842 }
2843 public override void Link()
2844 {
2845 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2846 a0ActionParser->SetAction(A0Action);
2847 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2848 a1ActionParser->SetAction(A1Action);
2849 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
2850 a2ActionParser->SetAction(A2Action);
2851 a2ActionParser->SetFailure(A2ActionFail);
2852 NonterminalParser* sizeNonterminalParser = GetNonterminal(ToUtf32("size"));
2853 sizeNonterminalParser->SetPre(Presize);
2854 sizeNonterminalParser->SetPost(Postsize);
2855 }
2856 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2857 {
2858 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2859 context->ctx->BeginParsingArguments();
2860 }
2861 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2862 {
2863 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2864 context->value = context->fromsize;
2865 }
2866 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2867 {
2868 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2869 context->ctx->EndParsingArguments();
2870 }
2871 public void A2ActionFail(ParsingData* parsingData)
2872 {
2873 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2874 context->ctx->EndParsingArguments();
2875 }
2876 public void Presize(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2877 {
2878 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2879 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2880 }
2881 public void Postsize(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2882 {
2883 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2884 if (matched)
2885 {
2886 UniquePtr<Object> fromsize_value = stack.Pop();
2887 context->fromsize = *cast<ValueObject<Node*>*>(fromsize_value.Get());
2888 }
2889 }
2890 public class Context : System.Text.Parsing.Context
2891 {
2892 public Context() : ctx(), value(), fromsize()
2893 {
2894 }
2895 public ParsingContext* ctx;
2896 public Node* value;
2897 public Node* fromsize;
2898 }
2899 }
2900
2901 public class NewInitializerRule : System.Text.Parsing.RuleParser
2902 {
2903 public NewInitializerRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2904 {
2905 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2906 SetValueTypeName(ToUtf32("ExpressionListNode*"));
2907 }
2908 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2909 {
2910 parsingData->PushContext(Id(), new Context());
2911 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2912 UniquePtr<Object> ctx_value = stack.Pop();
2913 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2914 }
2915 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2916 {
2917 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2918 if (matched)
2919 {
2920 stack.Push(UniquePtr<Object>(new ValueObject<ExpressionListNode*>(context->value)));
2921 }
2922 parsingData->PopContext(Id());
2923 }
2924 public override void Link()
2925 {
2926 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2927 a0ActionParser->SetAction(A0Action);
2928 NonterminalParser* argsNonterminalParser = GetNonterminal(ToUtf32("args"));
2929 argsNonterminalParser->SetPre(Preargs);
2930 argsNonterminalParser->SetPost(Postargs);
2931 }
2932 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2933 {
2934 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2935 context->value = context->fromargs;
2936 }
2937 public void Preargs(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2938 {
2939 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2940 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
2941 }
2942 public void Postargs(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2943 {
2944 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2945 if (matched)
2946 {
2947 UniquePtr<Object> fromargs_value = stack.Pop();
2948 context->fromargs = *cast<ValueObject<ExpressionListNode*>*>(fromargs_value.Get());
2949 }
2950 }
2951 public class Context : System.Text.Parsing.Context
2952 {
2953 public Context() : ctx(), value(), fromargs()
2954 {
2955 }
2956 public ParsingContext* ctx;
2957 public ExpressionListNode* value;
2958 public ExpressionListNode* fromargs;
2959 }
2960 }
2961
2962 public class DeleteExpressionRule : System.Text.Parsing.RuleParser
2963 {
2964 public DeleteExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2965 {
2966 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
2967 SetValueTypeName(ToUtf32("DeleteExpressionNode*"));
2968 AddLocalVariable(AttrOrVar(ToUtf32("bool"), ToUtf32("arrayDelete")));
2969 }
2970 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2971 {
2972 parsingData->PushContext(Id(), new Context());
2973 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2974 UniquePtr<Object> ctx_value = stack.Pop();
2975 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
2976 }
2977 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2978 {
2979 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2980 if (matched)
2981 {
2982 stack.Push(UniquePtr<Object>(new ValueObject<DeleteExpressionNode*>(context->value)));
2983 }
2984 parsingData->PopContext(Id());
2985 }
2986 public override void Link()
2987 {
2988 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2989 a0ActionParser->SetAction(A0Action);
2990 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2991 a1ActionParser->SetAction(A1Action);
2992 NonterminalParser* castExpressionNonterminalParser = GetNonterminal(ToUtf32("CastExpression"));
2993 castExpressionNonterminalParser->SetPre(PreCastExpression);
2994 castExpressionNonterminalParser->SetPost(PostCastExpression);
2995 }
2996 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2997 {
2998 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2999 context->value = new DeleteExpressionNode(span, context->fromCastExpression, context->arrayDelete);
3000 }
3001 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3002 {
3003 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3004 context->arrayDelete = true;
3005 }
3006 public void PreCastExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3007 {
3008 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3009 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3010 }
3011 public void PostCastExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3012 {
3013 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3014 if (matched)
3015 {
3016 UniquePtr<Object> fromCastExpression_value = stack.Pop();
3017 context->fromCastExpression = *cast<ValueObject<Node*>*>(fromCastExpression_value.Get());
3018 }
3019 }
3020 public class Context : System.Text.Parsing.Context
3021 {
3022 public Context() : ctx(), value(), arrayDelete(), fromCastExpression()
3023 {
3024 }
3025 public ParsingContext* ctx;
3026 public DeleteExpressionNode* value;
3027 public bool arrayDelete;
3028 public Node* fromCastExpression;
3029 }
3030 }
3031
3032 public class PostfixExpressionRule : System.Text.Parsing.RuleParser
3033 {
3034 public PostfixExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3035 {
3036 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
3037 SetValueTypeName(ToUtf32("Node*"));
3038 AddLocalVariable(AttrOrVar(ToUtf32("UniquePtr<Node>"), ToUtf32("node")));
3039 }
3040 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3041 {
3042 parsingData->PushContext(Id(), new Context());
3043 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3044 UniquePtr<Object> ctx_value = stack.Pop();
3045 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
3046 }
3047 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3048 {
3049 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3050 if (matched)
3051 {
3052 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
3053 }
3054 parsingData->PopContext(Id());
3055 }
3056 public override void Link()
3057 {
3058 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3059 a0ActionParser->SetAction(A0Action);
3060 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
3061 a1ActionParser->SetAction(A1Action);
3062 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
3063 a2ActionParser->SetAction(A2Action);
3064 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
3065 a3ActionParser->SetAction(A3Action);
3066 a3ActionParser->SetFailure(A3ActionFail);
3067 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
3068 a4ActionParser->SetAction(A4Action);
3069 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
3070 a5ActionParser->SetAction(A5Action);
3071 a5ActionParser->SetFailure(A5ActionFail);
3072 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
3073 a6ActionParser->SetAction(A6Action);
3074 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
3075 a7ActionParser->SetAction(A7Action);
3076 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
3077 a8ActionParser->SetAction(A8Action);
3078 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
3079 a9ActionParser->SetAction(A9Action);
3080 NonterminalParser* primaryExpressionNonterminalParser = GetNonterminal(ToUtf32("PrimaryExpression"));
3081 primaryExpressionNonterminalParser->SetPre(PrePrimaryExpression);
3082 primaryExpressionNonterminalParser->SetPost(PostPrimaryExpression);
3083 NonterminalParser* subscriptNonterminalParser = GetNonterminal(ToUtf32("subscript"));
3084 subscriptNonterminalParser->SetPre(Presubscript);
3085 subscriptNonterminalParser->SetPost(Postsubscript);
3086 NonterminalParser* argumentsNonterminalParser = GetNonterminal(ToUtf32("arguments"));
3087 argumentsNonterminalParser->SetPre(Prearguments);
3088 argumentsNonterminalParser->SetPost(Postarguments);
3089 NonterminalParser* id1NonterminalParser = GetNonterminal(ToUtf32("id1"));
3090 id1NonterminalParser->SetPre(Preid1);
3091 id1NonterminalParser->SetPost(Postid1);
3092 NonterminalParser* id2NonterminalParser = GetNonterminal(ToUtf32("id2"));
3093 id2NonterminalParser->SetPre(Preid2);
3094 id2NonterminalParser->SetPost(Postid2);
3095 }
3096 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3097 {
3098 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3099 context->value = context->node.Release();
3100 }
3101 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3102 {
3103 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3104 context->node.Reset(context->fromPrimaryExpression);
3105 }
3106 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3107 {
3108 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3109 context->ctx->BeginParsingArguments();
3110 }
3111 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3112 {
3113 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3114 context->node.Reset(new SubscriptExpressionNode(span, context->node.Release(), context->fromsubscript));
3115 context->ctx->EndParsingArguments();
3116 }
3117 public void A3ActionFail(ParsingData* parsingData)
3118 {
3119 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3120 context->ctx->EndParsingArguments();
3121 }
3122 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3123 {
3124 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3125 context->ctx->BeginParsingArguments();
3126 }
3127 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3128 {
3129 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3130 context->node.Reset(new InvokeExpressionNode(span, context->node.Release(), context->fromarguments));
3131 context->ctx->EndParsingArguments();
3132 }
3133 public void A5ActionFail(ParsingData* parsingData)
3134 {
3135 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3136 context->ctx->EndParsingArguments();
3137 }
3138 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3139 {
3140 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3141 context->node.Reset(new DotNode(span, context->node.Release(), context->fromid1));
3142 }
3143 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3144 {
3145 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3146 context->node.Reset(new ArrowNode(span, context->node.Release(), context->fromid2));
3147 }
3148 public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3149 {
3150 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3151 context->node.Reset(new PostfixIncrementNode(span, context->node.Release()));
3152 }
3153 public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3154 {
3155 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3156 context->node.Reset(new PostfixDecrementNode(span, context->node.Release()));
3157 }
3158 public void PrePrimaryExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3159 {
3160 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3161 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3162 }
3163 public void PostPrimaryExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3164 {
3165 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3166 if (matched)
3167 {
3168 UniquePtr<Object> fromPrimaryExpression_value = stack.Pop();
3169 context->fromPrimaryExpression = *cast<ValueObject<Node*>*>(fromPrimaryExpression_value.Get());
3170 }
3171 }
3172 public void Presubscript(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3173 {
3174 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3175 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3176 }
3177 public void Postsubscript(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3178 {
3179 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3180 if (matched)
3181 {
3182 UniquePtr<Object> fromsubscript_value = stack.Pop();
3183 context->fromsubscript = *cast<ValueObject<Node*>*>(fromsubscript_value.Get());
3184 }
3185 }
3186 public void Prearguments(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3187 {
3188 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3189 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3190 }
3191 public void Postarguments(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3192 {
3193 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3194 if (matched)
3195 {
3196 UniquePtr<Object> fromarguments_value = stack.Pop();
3197 context->fromarguments = *cast<ValueObject<ExpressionListNode*>*>(fromarguments_value.Get());
3198 }
3199 }
3200 public void Preid1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3201 {
3202 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3203 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3204 }
3205 public void Postid1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3206 {
3207 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3208 if (matched)
3209 {
3210 UniquePtr<Object> fromid1_value = stack.Pop();
3211 context->fromid1 = *cast<ValueObject<Node*>*>(fromid1_value.Get());
3212 }
3213 }
3214 public void Preid2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3215 {
3216 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3217 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3218 }
3219 public void Postid2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3220 {
3221 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3222 if (matched)
3223 {
3224 UniquePtr<Object> fromid2_value = stack.Pop();
3225 context->fromid2 = *cast<ValueObject<Node*>*>(fromid2_value.Get());
3226 }
3227 }
3228 public class Context : System.Text.Parsing.Context
3229 {
3230 public Context() : ctx(), value(), node(), fromPrimaryExpression(), fromsubscript(), fromarguments(), fromid1(), fromid2()
3231 {
3232 }
3233 public ParsingContext* ctx;
3234 public Node* value;
3235 public UniquePtr<Node> node;
3236 public Node* fromPrimaryExpression;
3237 public Node* fromsubscript;
3238 public ExpressionListNode* fromarguments;
3239 public Node* fromid1;
3240 public Node* fromid2;
3241 }
3242 }
3243
3244 public class PrimaryExpressionRule : System.Text.Parsing.RuleParser
3245 {
3246 public PrimaryExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3247 {
3248 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
3249 SetValueTypeName(ToUtf32("Node*"));
3250 }
3251 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3252 {
3253 parsingData->PushContext(Id(), new Context());
3254 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3255 UniquePtr<Object> ctx_value = stack.Pop();
3256 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
3257 }
3258 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3259 {
3260 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3261 if (matched)
3262 {
3263 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
3264 }
3265 parsingData->PopContext(Id());
3266 }
3267 public override void Link()
3268 {
3269 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3270 a0ActionParser->SetAction(A0Action);
3271 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
3272 a1ActionParser->SetAction(A1Action);
3273 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
3274 a2ActionParser->SetAction(A2Action);
3275 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
3276 a3ActionParser->SetAction(A3Action);
3277 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
3278 a4ActionParser->SetAction(A4Action);
3279 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
3280 a5ActionParser->SetAction(A5Action);
3281 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
3282 a6ActionParser->SetAction(A6Action);
3283 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
3284 a7ActionParser->SetAction(A7Action);
3285 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
3286 a8ActionParser->SetAction(A8Action);
3287 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
3288 a9ActionParser->SetAction(A9Action);
3289 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
3290 a10ActionParser->SetAction(A10Action);
3291 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
3292 a11ActionParser->SetAction(A11Action);
3293 ActionParser* a12ActionParser = GetAction(ToUtf32("A12"));
3294 a12ActionParser->SetAction(A12Action);
3295 NonterminalParser* literalNonterminalParser = GetNonterminal(ToUtf32("Literal"));
3296 literalNonterminalParser->SetPost(PostLiteral);
3297 NonterminalParser* definedExprNonterminalParser = GetNonterminal(ToUtf32("DefinedExpr"));
3298 definedExprNonterminalParser->SetPost(PostDefinedExpr);
3299 NonterminalParser* exprNonterminalParser = GetNonterminal(ToUtf32("expr"));
3300 exprNonterminalParser->SetPre(Preexpr);
3301 exprNonterminalParser->SetPost(Postexpr);
3302 NonterminalParser* cppCastExpressionNonterminalParser = GetNonterminal(ToUtf32("CppCastExpression"));
3303 cppCastExpressionNonterminalParser->SetPre(PreCppCastExpression);
3304 cppCastExpressionNonterminalParser->SetPost(PostCppCastExpression);
3305 NonterminalParser* typeIdExpressionNonterminalParser = GetNonterminal(ToUtf32("TypeIdExpression"));
3306 typeIdExpressionNonterminalParser->SetPre(PreTypeIdExpression);
3307 typeIdExpressionNonterminalParser->SetPost(PostTypeIdExpression);
3308 NonterminalParser* s1NonterminalParser = GetNonterminal(ToUtf32("s1"));
3309 s1NonterminalParser->SetPost(Posts1);
3310 NonterminalParser* args1NonterminalParser = GetNonterminal(ToUtf32("args1"));
3311 args1NonterminalParser->SetPre(Preargs1);
3312 args1NonterminalParser->SetPost(Postargs1);
3313 NonterminalParser* s2NonterminalParser = GetNonterminal(ToUtf32("s2"));
3314 s2NonterminalParser->SetPost(Posts2);
3315 NonterminalParser* b1NonterminalParser = GetNonterminal(ToUtf32("b1"));
3316 b1NonterminalParser->SetPre(Preb1);
3317 b1NonterminalParser->SetPost(Postb1);
3318 NonterminalParser* t1NonterminalParser = GetNonterminal(ToUtf32("t1"));
3319 t1NonterminalParser->SetPre(Pret1);
3320 t1NonterminalParser->SetPost(Postt1);
3321 NonterminalParser* args2NonterminalParser = GetNonterminal(ToUtf32("args2"));
3322 args2NonterminalParser->SetPre(Preargs2);
3323 args2NonterminalParser->SetPost(Postargs2);
3324 NonterminalParser* t2NonterminalParser = GetNonterminal(ToUtf32("t2"));
3325 t2NonterminalParser->SetPre(Pret2);
3326 t2NonterminalParser->SetPost(Postt2);
3327 NonterminalParser* b2NonterminalParser = GetNonterminal(ToUtf32("b2"));
3328 b2NonterminalParser->SetPre(Preb2);
3329 b2NonterminalParser->SetPost(Postb2);
3330 NonterminalParser* idExpressionNonterminalParser = GetNonterminal(ToUtf32("IdExpression"));
3331 idExpressionNonterminalParser->SetPre(PreIdExpression);
3332 idExpressionNonterminalParser->SetPost(PostIdExpression);
3333 NonterminalParser* lambdaExpressionNonterminalParser = GetNonterminal(ToUtf32("LambdaExpression"));
3334 lambdaExpressionNonterminalParser->SetPre(PreLambdaExpression);
3335 lambdaExpressionNonterminalParser->SetPost(PostLambdaExpression);
3336 }
3337 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3338 {
3339 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3340 context->value = context->fromLiteral;
3341 }
3342 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3343 {
3344 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3345 context->value = new ThisNode(span);
3346 }
3347 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3348 {
3349 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3350 pass = context->ctx->AcceptDefined();
3351 }
3352 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3353 {
3354 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3355 context->value = context->fromDefinedExpr;
3356 }
3357 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3358 {
3359 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3360 context->value = new ParenthesizedExpressionNode(span, context->fromexpr);
3361 }
3362 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3363 {
3364 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3365 context->value = context->fromCppCastExpression;
3366 }
3367 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3368 {
3369 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3370 context->value = context->fromTypeIdExpression;
3371 }
3372 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3373 {
3374 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3375 context->value = new InvokeExpressionNode(span, new SimpleTypeNode(span, context->froms1), context->fromargs1);
3376 }
3377 public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3378 {
3379 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3380 context->value = new InvokeExpressionNode(span, new SimpleTypeNode(span, context->froms2), context->fromb1);
3381 }
3382 public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3383 {
3384 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3385 context->value = new InvokeExpressionNode(span, context->fromt1, context->fromargs2);
3386 }
3387 public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3388 {
3389 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3390 context->value = new InvokeExpressionNode(span, context->fromt2, context->fromb2);
3391 }
3392 public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3393 {
3394 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3395 context->value = context->fromIdExpression;
3396 }
3397 public void A12Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3398 {
3399 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3400 context->value = context->fromLambdaExpression;
3401 }
3402 public void PostLiteral(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3403 {
3404 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3405 if (matched)
3406 {
3407 UniquePtr<Object> fromLiteral_value = stack.Pop();
3408 context->fromLiteral = *cast<ValueObject<LiteralNode*>*>(fromLiteral_value.Get());
3409 }
3410 }
3411 public void PostDefinedExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3412 {
3413 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3414 if (matched)
3415 {
3416 UniquePtr<Object> fromDefinedExpr_value = stack.Pop();
3417 context->fromDefinedExpr = *cast<ValueObject<Node*>*>(fromDefinedExpr_value.Get());
3418 }
3419 }
3420 public void Preexpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3421 {
3422 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3423 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3424 }
3425 public void Postexpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3426 {
3427 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3428 if (matched)
3429 {
3430 UniquePtr<Object> fromexpr_value = stack.Pop();
3431 context->fromexpr = *cast<ValueObject<Node*>*>(fromexpr_value.Get());
3432 }
3433 }
3434 public void PreCppCastExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3435 {
3436 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3437 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3438 }
3439 public void PostCppCastExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3440 {
3441 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3442 if (matched)
3443 {
3444 UniquePtr<Object> fromCppCastExpression_value = stack.Pop();
3445 context->fromCppCastExpression = *cast<ValueObject<Node*>*>(fromCppCastExpression_value.Get());
3446 }
3447 }
3448 public void PreTypeIdExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3449 {
3450 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3451 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3452 }
3453 public void PostTypeIdExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3454 {
3455 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3456 if (matched)
3457 {
3458 UniquePtr<Object> fromTypeIdExpression_value = stack.Pop();
3459 context->fromTypeIdExpression = *cast<ValueObject<Node*>*>(fromTypeIdExpression_value.Get());
3460 }
3461 }
3462 public void Posts1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3463 {
3464 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3465 if (matched)
3466 {
3467 UniquePtr<Object> froms1_value = stack.Pop();
3468 context->froms1 = *cast<ValueObject<SimpleTypeSpecifiers>*>(froms1_value.Get());
3469 }
3470 }
3471 public void Preargs1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3472 {
3473 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3474 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3475 }
3476 public void Postargs1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3477 {
3478 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3479 if (matched)
3480 {
3481 UniquePtr<Object> fromargs1_value = stack.Pop();
3482 context->fromargs1 = *cast<ValueObject<ExpressionListNode*>*>(fromargs1_value.Get());
3483 }
3484 }
3485 public void Posts2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3486 {
3487 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3488 if (matched)
3489 {
3490 UniquePtr<Object> froms2_value = stack.Pop();
3491 context->froms2 = *cast<ValueObject<SimpleTypeSpecifiers>*>(froms2_value.Get());
3492 }
3493 }
3494 public void Preb1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3495 {
3496 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3497 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3498 }
3499 public void Postb1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3500 {
3501 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3502 if (matched)
3503 {
3504 UniquePtr<Object> fromb1_value = stack.Pop();
3505 context->fromb1 = *cast<ValueObject<BracedInitializerListNode*>*>(fromb1_value.Get());
3506 }
3507 }
3508 public void Pret1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3509 {
3510 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3511 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3512 }
3513 public void Postt1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3514 {
3515 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3516 if (matched)
3517 {
3518 UniquePtr<Object> fromt1_value = stack.Pop();
3519 context->fromt1 = *cast<ValueObject<Node*>*>(fromt1_value.Get());
3520 }
3521 }
3522 public void Preargs2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3523 {
3524 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3525 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3526 }
3527 public void Postargs2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3528 {
3529 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3530 if (matched)
3531 {
3532 UniquePtr<Object> fromargs2_value = stack.Pop();
3533 context->fromargs2 = *cast<ValueObject<ExpressionListNode*>*>(fromargs2_value.Get());
3534 }
3535 }
3536 public void Pret2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3537 {
3538 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3539 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3540 }
3541 public void Postt2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3542 {
3543 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3544 if (matched)
3545 {
3546 UniquePtr<Object> fromt2_value = stack.Pop();
3547 context->fromt2 = *cast<ValueObject<Node*>*>(fromt2_value.Get());
3548 }
3549 }
3550 public void Preb2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3551 {
3552 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3553 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3554 }
3555 public void Postb2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3556 {
3557 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3558 if (matched)
3559 {
3560 UniquePtr<Object> fromb2_value = stack.Pop();
3561 context->fromb2 = *cast<ValueObject<BracedInitializerListNode*>*>(fromb2_value.Get());
3562 }
3563 }
3564 public void PreIdExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3565 {
3566 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3567 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3568 }
3569 public void PostIdExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3570 {
3571 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3572 if (matched)
3573 {
3574 UniquePtr<Object> fromIdExpression_value = stack.Pop();
3575 context->fromIdExpression = *cast<ValueObject<Node*>*>(fromIdExpression_value.Get());
3576 }
3577 }
3578 public void PreLambdaExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3579 {
3580 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3581 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3582 }
3583 public void PostLambdaExpression(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3584 {
3585 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3586 if (matched)
3587 {
3588 UniquePtr<Object> fromLambdaExpression_value = stack.Pop();
3589 context->fromLambdaExpression = *cast<ValueObject<LambdaExpressionNode*>*>(fromLambdaExpression_value.Get());
3590 }
3591 }
3592 public class Context : System.Text.Parsing.Context
3593 {
3594 public Context() : ctx(), value(), fromLiteral(), fromDefinedExpr(), fromexpr(), fromCppCastExpression(), fromTypeIdExpression(), froms1(), fromargs1(), froms2(), fromb1(), fromt1(), fromargs2(), fromt2(), fromb2(), fromIdExpression(), fromLambdaExpression()
3595 {
3596 }
3597 public ParsingContext* ctx;
3598 public Node* value;
3599 public LiteralNode* fromLiteral;
3600 public Node* fromDefinedExpr;
3601 public Node* fromexpr;
3602 public Node* fromCppCastExpression;
3603 public Node* fromTypeIdExpression;
3604 public SimpleTypeSpecifiers froms1;
3605 public ExpressionListNode* fromargs1;
3606 public SimpleTypeSpecifiers froms2;
3607 public BracedInitializerListNode* fromb1;
3608 public Node* fromt1;
3609 public ExpressionListNode* fromargs2;
3610 public Node* fromt2;
3611 public BracedInitializerListNode* fromb2;
3612 public Node* fromIdExpression;
3613 public LambdaExpressionNode* fromLambdaExpression;
3614 }
3615 }
3616
3617 public class CppCastExpressionRule : System.Text.Parsing.RuleParser
3618 {
3619 public CppCastExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3620 {
3621 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
3622 SetValueTypeName(ToUtf32("Node*"));
3623 AddLocalVariable(AttrOrVar(ToUtf32("CppCast"), ToUtf32("cast_")));
3624 }
3625 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3626 {
3627 parsingData->PushContext(Id(), new Context());
3628 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3629 UniquePtr<Object> ctx_value = stack.Pop();
3630 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
3631 }
3632 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3633 {
3634 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3635 if (matched)
3636 {
3637 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
3638 }
3639 parsingData->PopContext(Id());
3640 }
3641 public override void Link()
3642 {
3643 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3644 a0ActionParser->SetAction(A0Action);
3645 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
3646 a1ActionParser->SetAction(A1Action);
3647 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
3648 a2ActionParser->SetAction(A2Action);
3649 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
3650 a3ActionParser->SetAction(A3Action);
3651 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
3652 a4ActionParser->SetAction(A4Action);
3653 NonterminalParser* t1NonterminalParser = GetNonterminal(ToUtf32("t1"));
3654 t1NonterminalParser->SetPre(Pret1);
3655 t1NonterminalParser->SetPost(Postt1);
3656 NonterminalParser* e1NonterminalParser = GetNonterminal(ToUtf32("e1"));
3657 e1NonterminalParser->SetPre(Pree1);
3658 e1NonterminalParser->SetPost(Poste1);
3659 }
3660 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3661 {
3662 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3663 context->value = new CppCastNode(span, context->cast_, context->fromt1, context->frome1);
3664 }
3665 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3666 {
3667 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3668 context->cast_ = CppCast.dynamicCast;
3669 }
3670 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3671 {
3672 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3673 context->cast_ = CppCast.staticCast;
3674 }
3675 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3676 {
3677 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3678 context->cast_ = CppCast.reinterpretCast;
3679 }
3680 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3681 {
3682 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3683 context->cast_ = CppCast.constCast;
3684 }
3685 public void Pret1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3686 {
3687 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3688 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3689 }
3690 public void Postt1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3691 {
3692 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3693 if (matched)
3694 {
3695 UniquePtr<Object> fromt1_value = stack.Pop();
3696 context->fromt1 = *cast<ValueObject<Node*>*>(fromt1_value.Get());
3697 }
3698 }
3699 public void Pree1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3700 {
3701 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3702 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3703 }
3704 public void Poste1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3705 {
3706 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3707 if (matched)
3708 {
3709 UniquePtr<Object> frome1_value = stack.Pop();
3710 context->frome1 = *cast<ValueObject<Node*>*>(frome1_value.Get());
3711 }
3712 }
3713 public class Context : System.Text.Parsing.Context
3714 {
3715 public Context() : ctx(), value(), cast_(), fromt1(), frome1()
3716 {
3717 }
3718 public ParsingContext* ctx;
3719 public Node* value;
3720 public CppCast cast_;
3721 public Node* fromt1;
3722 public Node* frome1;
3723 }
3724 }
3725
3726 public class DefinedExprRule : System.Text.Parsing.RuleParser
3727 {
3728 public DefinedExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3729 {
3730 SetValueTypeName(ToUtf32("Node*"));
3731 }
3732 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3733 {
3734 parsingData->PushContext(Id(), new Context());
3735 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3736 }
3737 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3738 {
3739 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3740 if (matched)
3741 {
3742 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
3743 }
3744 parsingData->PopContext(Id());
3745 }
3746 public override void Link()
3747 {
3748 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3749 a0ActionParser->SetAction(A0Action);
3750 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
3751 a1ActionParser->SetAction(A1Action);
3752 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
3753 a2ActionParser->SetAction(A2Action);
3754 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
3755 a3ActionParser->SetAction(A3Action);
3756 NonterminalParser* id1NonterminalParser = GetNonterminal(ToUtf32("id1"));
3757 id1NonterminalParser->SetPost(Postid1);
3758 NonterminalParser* id2NonterminalParser = GetNonterminal(ToUtf32("id2"));
3759 id2NonterminalParser->SetPost(Postid2);
3760 NonterminalParser* lit1NonterminalParser = GetNonterminal(ToUtf32("lit1"));
3761 lit1NonterminalParser->SetPost(Postlit1);
3762 NonterminalParser* lit2NonterminalParser = GetNonterminal(ToUtf32("lit2"));
3763 lit2NonterminalParser->SetPost(Postlit2);
3764 }
3765 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3766 {
3767 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3768 context->value = new DefinedNode(span, context->fromid1);
3769 }
3770 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3771 {
3772 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3773 context->value = new DefinedNode(span, context->fromid2);
3774 }
3775 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3776 {
3777 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3778 context->value = new BooleanLiteralNode(span, true);
3779 }
3780 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3781 {
3782 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3783 context->value = new BooleanLiteralNode(span, true);
3784 }
3785 public void Postid1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3786 {
3787 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3788 if (matched)
3789 {
3790 UniquePtr<Object> fromid1_value = stack.Pop();
3791 context->fromid1 = *cast<ValueObject<ustring>*>(fromid1_value.Get());
3792 }
3793 }
3794 public void Postid2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3795 {
3796 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3797 if (matched)
3798 {
3799 UniquePtr<Object> fromid2_value = stack.Pop();
3800 context->fromid2 = *cast<ValueObject<ustring>*>(fromid2_value.Get());
3801 }
3802 }
3803 public void Postlit1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3804 {
3805 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3806 if (matched)
3807 {
3808 UniquePtr<Object> fromlit1_value = stack.Pop();
3809 context->fromlit1 = *cast<ValueObject<LiteralNode*>*>(fromlit1_value.Get());
3810 }
3811 }
3812 public void Postlit2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3813 {
3814 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3815 if (matched)
3816 {
3817 UniquePtr<Object> fromlit2_value = stack.Pop();
3818 context->fromlit2 = *cast<ValueObject<LiteralNode*>*>(fromlit2_value.Get());
3819 }
3820 }
3821 public class Context : System.Text.Parsing.Context
3822 {
3823 public Context() : value(), fromid1(), fromid2(), fromlit1(), fromlit2()
3824 {
3825 }
3826 public Node* value;
3827 public ustring fromid1;
3828 public ustring fromid2;
3829 public LiteralNode* fromlit1;
3830 public LiteralNode* fromlit2;
3831 }
3832 }
3833
3834 public class TypeIdExpressionRule : System.Text.Parsing.RuleParser
3835 {
3836 public TypeIdExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3837 {
3838 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
3839 SetValueTypeName(ToUtf32("Node*"));
3840 }
3841 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3842 {
3843 parsingData->PushContext(Id(), new Context());
3844 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3845 UniquePtr<Object> ctx_value = stack.Pop();
3846 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
3847 }
3848 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3849 {
3850 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3851 if (matched)
3852 {
3853 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
3854 }
3855 parsingData->PopContext(Id());
3856 }
3857 public override void Link()
3858 {
3859 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3860 a0ActionParser->SetAction(A0Action);
3861 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
3862 a1ActionParser->SetAction(A1Action);
3863 NonterminalParser* t1NonterminalParser = GetNonterminal(ToUtf32("t1"));
3864 t1NonterminalParser->SetPre(Pret1);
3865 t1NonterminalParser->SetPost(Postt1);
3866 NonterminalParser* e1NonterminalParser = GetNonterminal(ToUtf32("e1"));
3867 e1NonterminalParser->SetPre(Pree1);
3868 e1NonterminalParser->SetPost(Poste1);
3869 }
3870 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3871 {
3872 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3873 context->value = new TypeIdNode(span, context->fromt1);
3874 }
3875 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3876 {
3877 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3878 context->value = new TypeIdNode(span, context->frome1);
3879 }
3880 public void Pret1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3881 {
3882 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3883 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3884 }
3885 public void Postt1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3886 {
3887 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3888 if (matched)
3889 {
3890 UniquePtr<Object> fromt1_value = stack.Pop();
3891 context->fromt1 = *cast<ValueObject<Node*>*>(fromt1_value.Get());
3892 }
3893 }
3894 public void Pree1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3895 {
3896 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3897 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3898 }
3899 public void Poste1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3900 {
3901 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3902 if (matched)
3903 {
3904 UniquePtr<Object> frome1_value = stack.Pop();
3905 context->frome1 = *cast<ValueObject<Node*>*>(frome1_value.Get());
3906 }
3907 }
3908 public class Context : System.Text.Parsing.Context
3909 {
3910 public Context() : ctx(), value(), fromt1(), frome1()
3911 {
3912 }
3913 public ParsingContext* ctx;
3914 public Node* value;
3915 public Node* fromt1;
3916 public Node* frome1;
3917 }
3918 }
3919
3920 public class IdExpressionRule : System.Text.Parsing.RuleParser
3921 {
3922 public IdExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3923 {
3924 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
3925 SetValueTypeName(ToUtf32("Node*"));
3926 }
3927 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3928 {
3929 parsingData->PushContext(Id(), new Context());
3930 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3931 UniquePtr<Object> ctx_value = stack.Pop();
3932 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
3933 }
3934 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3935 {
3936 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3937 if (matched)
3938 {
3939 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
3940 }
3941 parsingData->PopContext(Id());
3942 }
3943 public override void Link()
3944 {
3945 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3946 a0ActionParser->SetAction(A0Action);
3947 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
3948 a1ActionParser->SetAction(A1Action);
3949 NonterminalParser* qualifiedIdExprNonterminalParser = GetNonterminal(ToUtf32("QualifiedIdExpr"));
3950 qualifiedIdExprNonterminalParser->SetPre(PreQualifiedIdExpr);
3951 qualifiedIdExprNonterminalParser->SetPost(PostQualifiedIdExpr);
3952 NonterminalParser* unqualifiedIdExprNonterminalParser = GetNonterminal(ToUtf32("UnqualifiedIdExpr"));
3953 unqualifiedIdExprNonterminalParser->SetPre(PreUnqualifiedIdExpr);
3954 unqualifiedIdExprNonterminalParser->SetPost(PostUnqualifiedIdExpr);
3955 }
3956 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3957 {
3958 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3959 context->value = context->fromQualifiedIdExpr;
3960 }
3961 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3962 {
3963 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3964 context->value = context->fromUnqualifiedIdExpr;
3965 }
3966 public void PreQualifiedIdExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3967 {
3968 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3969 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3970 }
3971 public void PostQualifiedIdExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3972 {
3973 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3974 if (matched)
3975 {
3976 UniquePtr<Object> fromQualifiedIdExpr_value = stack.Pop();
3977 context->fromQualifiedIdExpr = *cast<ValueObject<Node*>*>(fromQualifiedIdExpr_value.Get());
3978 }
3979 }
3980 public void PreUnqualifiedIdExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3981 {
3982 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3983 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
3984 }
3985 public void PostUnqualifiedIdExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3986 {
3987 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3988 if (matched)
3989 {
3990 UniquePtr<Object> fromUnqualifiedIdExpr_value = stack.Pop();
3991 context->fromUnqualifiedIdExpr = *cast<ValueObject<Node*>*>(fromUnqualifiedIdExpr_value.Get());
3992 }
3993 }
3994 public class Context : System.Text.Parsing.Context
3995 {
3996 public Context() : ctx(), value(), fromQualifiedIdExpr(), fromUnqualifiedIdExpr()
3997 {
3998 }
3999 public ParsingContext* ctx;
4000 public Node* value;
4001 public Node* fromQualifiedIdExpr;
4002 public Node* fromUnqualifiedIdExpr;
4003 }
4004 }
4005
4006 public class UnqualifiedIdExprRule : System.Text.Parsing.RuleParser
4007 {
4008 public UnqualifiedIdExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4009 {
4010 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
4011 SetValueTypeName(ToUtf32("Node*"));
4012 }
4013 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4014 {
4015 parsingData->PushContext(Id(), new Context());
4016 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4017 UniquePtr<Object> ctx_value = stack.Pop();
4018 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
4019 }
4020 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4021 {
4022 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4023 if (matched)
4024 {
4025 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
4026 }
4027 parsingData->PopContext(Id());
4028 }
4029 public override void Link()
4030 {
4031 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4032 a0ActionParser->SetAction(A0Action);
4033 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
4034 a1ActionParser->SetAction(A1Action);
4035 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
4036 a2ActionParser->SetAction(A2Action);
4037 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
4038 a3ActionParser->SetAction(A3Action);
4039 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
4040 a4ActionParser->SetAction(A4Action);
4041 NonterminalParser* templateIdNonterminalParser = GetNonterminal(ToUtf32("TemplateId"));
4042 templateIdNonterminalParser->SetPre(PreTemplateId);
4043 templateIdNonterminalParser->SetPost(PostTemplateId);
4044 NonterminalParser* id1NonterminalParser = GetNonterminal(ToUtf32("id1"));
4045 id1NonterminalParser->SetPost(Postid1);
4046 NonterminalParser* operatorFunctionIdNonterminalParser = GetNonterminal(ToUtf32("OperatorFunctionId"));
4047 operatorFunctionIdNonterminalParser->SetPost(PostOperatorFunctionId);
4048 NonterminalParser* conversionFunctionIdNonterminalParser = GetNonterminal(ToUtf32("ConversionFunctionId"));
4049 conversionFunctionIdNonterminalParser->SetPre(PreConversionFunctionId);
4050 conversionFunctionIdNonterminalParser->SetPost(PostConversionFunctionId);
4051 NonterminalParser* id2NonterminalParser = GetNonterminal(ToUtf32("id2"));
4052 id2NonterminalParser->SetPost(Postid2);
4053 }
4054 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4055 {
4056 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4057 context->value = context->fromTemplateId;
4058 }
4059 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4060 {
4061 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4062 context->value = context->fromid1;
4063 }
4064 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4065 {
4066 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4067 context->value = context->fromOperatorFunctionId;
4068 }
4069 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4070 {
4071 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4072 context->value = context->fromConversionFunctionId;
4073 }
4074 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4075 {
4076 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4077 context->value = new DestructorIdNode(span, context->fromid2);
4078 }
4079 public void PreTemplateId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4080 {
4081 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4082 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4083 }
4084 public void PostTemplateId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4085 {
4086 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4087 if (matched)
4088 {
4089 UniquePtr<Object> fromTemplateId_value = stack.Pop();
4090 context->fromTemplateId = *cast<ValueObject<TemplateIdNode*>*>(fromTemplateId_value.Get());
4091 }
4092 }
4093 public void Postid1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4094 {
4095 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4096 if (matched)
4097 {
4098 UniquePtr<Object> fromid1_value = stack.Pop();
4099 context->fromid1 = *cast<ValueObject<IdentifierNode*>*>(fromid1_value.Get());
4100 }
4101 }
4102 public void PostOperatorFunctionId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4103 {
4104 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4105 if (matched)
4106 {
4107 UniquePtr<Object> fromOperatorFunctionId_value = stack.Pop();
4108 context->fromOperatorFunctionId = *cast<ValueObject<OperatorFunctionIdNode*>*>(fromOperatorFunctionId_value.Get());
4109 }
4110 }
4111 public void PreConversionFunctionId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4112 {
4113 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4114 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4115 }
4116 public void PostConversionFunctionId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4117 {
4118 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4119 if (matched)
4120 {
4121 UniquePtr<Object> fromConversionFunctionId_value = stack.Pop();
4122 context->fromConversionFunctionId = *cast<ValueObject<ConversionFunctionIdNode*>*>(fromConversionFunctionId_value.Get());
4123 }
4124 }
4125 public void Postid2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4126 {
4127 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4128 if (matched)
4129 {
4130 UniquePtr<Object> fromid2_value = stack.Pop();
4131 context->fromid2 = *cast<ValueObject<IdentifierNode*>*>(fromid2_value.Get());
4132 }
4133 }
4134 public class Context : System.Text.Parsing.Context
4135 {
4136 public Context() : ctx(), value(), fromTemplateId(), fromid1(), fromOperatorFunctionId(), fromConversionFunctionId(), fromid2()
4137 {
4138 }
4139 public ParsingContext* ctx;
4140 public Node* value;
4141 public TemplateIdNode* fromTemplateId;
4142 public IdentifierNode* fromid1;
4143 public OperatorFunctionIdNode* fromOperatorFunctionId;
4144 public ConversionFunctionIdNode* fromConversionFunctionId;
4145 public IdentifierNode* fromid2;
4146 }
4147 }
4148
4149 public class QualifiedIdExprRule : System.Text.Parsing.RuleParser
4150 {
4151 public QualifiedIdExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4152 {
4153 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
4154 SetValueTypeName(ToUtf32("Node*"));
4155 }
4156 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4157 {
4158 parsingData->PushContext(Id(), new Context());
4159 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4160 UniquePtr<Object> ctx_value = stack.Pop();
4161 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
4162 }
4163 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4164 {
4165 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4166 if (matched)
4167 {
4168 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
4169 }
4170 parsingData->PopContext(Id());
4171 }
4172 public override void Link()
4173 {
4174 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4175 a0ActionParser->SetAction(A0Action);
4176 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
4177 a1ActionParser->SetAction(A1Action);
4178 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
4179 a2ActionParser->SetAction(A2Action);
4180 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
4181 a3ActionParser->SetAction(A3Action);
4182 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
4183 a4ActionParser->SetAction(A4Action);
4184 NonterminalParser* templateIdNonterminalParser = GetNonterminal(ToUtf32("TemplateId"));
4185 templateIdNonterminalParser->SetPre(PreTemplateId);
4186 templateIdNonterminalParser->SetPost(PostTemplateId);
4187 NonterminalParser* nsNonterminalParser = GetNonterminal(ToUtf32("ns"));
4188 nsNonterminalParser->SetPre(Prens);
4189 nsNonterminalParser->SetPost(Postns);
4190 NonterminalParser* ud1NonterminalParser = GetNonterminal(ToUtf32("ud1"));
4191 ud1NonterminalParser->SetPre(Preud1);
4192 ud1NonterminalParser->SetPost(Postud1);
4193 NonterminalParser* identifierNonterminalParser = GetNonterminal(ToUtf32("Identifier"));
4194 identifierNonterminalParser->SetPost(PostIdentifier);
4195 NonterminalParser* operatorFunctionIdNonterminalParser = GetNonterminal(ToUtf32("OperatorFunctionId"));
4196 operatorFunctionIdNonterminalParser->SetPost(PostOperatorFunctionId);
4197 NonterminalParser* ns2NonterminalParser = GetNonterminal(ToUtf32("ns2"));
4198 ns2NonterminalParser->SetPre(Prens2);
4199 ns2NonterminalParser->SetPost(Postns2);
4200 NonterminalParser* uid2NonterminalParser = GetNonterminal(ToUtf32("uid2"));
4201 uid2NonterminalParser->SetPre(Preuid2);
4202 uid2NonterminalParser->SetPost(Postuid2);
4203 }
4204 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4205 {
4206 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4207 context->value = new ColonColonNode(span, null, context->fromTemplateId);
4208 }
4209 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4210 {
4211 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4212 context->value = new ColonColonNode(span, null, new ColonColonNode(span, context->fromns, context->fromud1));
4213 }
4214 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4215 {
4216 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4217 context->value = new ColonColonNode(span, null, context->fromIdentifier);
4218 }
4219 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4220 {
4221 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4222 context->value = new ColonColonNode(span, null, context->fromOperatorFunctionId);
4223 }
4224 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4225 {
4226 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4227 context->value = new ColonColonNode(span, context->fromns2, context->fromuid2);
4228 }
4229 public void PreTemplateId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4230 {
4231 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4232 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4233 }
4234 public void PostTemplateId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4235 {
4236 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4237 if (matched)
4238 {
4239 UniquePtr<Object> fromTemplateId_value = stack.Pop();
4240 context->fromTemplateId = *cast<ValueObject<TemplateIdNode*>*>(fromTemplateId_value.Get());
4241 }
4242 }
4243 public void Prens(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4244 {
4245 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4246 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4247 }
4248 public void Postns(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4249 {
4250 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4251 if (matched)
4252 {
4253 UniquePtr<Object> fromns_value = stack.Pop();
4254 context->fromns = *cast<ValueObject<Node*>*>(fromns_value.Get());
4255 }
4256 }
4257 public void Preud1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4258 {
4259 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4260 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4261 }
4262 public void Postud1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4263 {
4264 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4265 if (matched)
4266 {
4267 UniquePtr<Object> fromud1_value = stack.Pop();
4268 context->fromud1 = *cast<ValueObject<Node*>*>(fromud1_value.Get());
4269 }
4270 }
4271 public void PostIdentifier(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4272 {
4273 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4274 if (matched)
4275 {
4276 UniquePtr<Object> fromIdentifier_value = stack.Pop();
4277 context->fromIdentifier = *cast<ValueObject<IdentifierNode*>*>(fromIdentifier_value.Get());
4278 }
4279 }
4280 public void PostOperatorFunctionId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4281 {
4282 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4283 if (matched)
4284 {
4285 UniquePtr<Object> fromOperatorFunctionId_value = stack.Pop();
4286 context->fromOperatorFunctionId = *cast<ValueObject<OperatorFunctionIdNode*>*>(fromOperatorFunctionId_value.Get());
4287 }
4288 }
4289 public void Prens2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4290 {
4291 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4292 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4293 }
4294 public void Postns2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4295 {
4296 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4297 if (matched)
4298 {
4299 UniquePtr<Object> fromns2_value = stack.Pop();
4300 context->fromns2 = *cast<ValueObject<Node*>*>(fromns2_value.Get());
4301 }
4302 }
4303 public void Preuid2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4304 {
4305 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4306 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4307 }
4308 public void Postuid2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4309 {
4310 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4311 if (matched)
4312 {
4313 UniquePtr<Object> fromuid2_value = stack.Pop();
4314 context->fromuid2 = *cast<ValueObject<Node*>*>(fromuid2_value.Get());
4315 }
4316 }
4317 public class Context : System.Text.Parsing.Context
4318 {
4319 public Context() : ctx(), value(), fromTemplateId(), fromns(), fromud1(), fromIdentifier(), fromOperatorFunctionId(), fromns2(), fromuid2()
4320 {
4321 }
4322 public ParsingContext* ctx;
4323 public Node* value;
4324 public TemplateIdNode* fromTemplateId;
4325 public Node* fromns;
4326 public Node* fromud1;
4327 public IdentifierNode* fromIdentifier;
4328 public OperatorFunctionIdNode* fromOperatorFunctionId;
4329 public Node* fromns2;
4330 public Node* fromuid2;
4331 }
4332 }
4333
4334 public class OperatorFunctionIdRule : System.Text.Parsing.RuleParser
4335 {
4336 public OperatorFunctionIdRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4337 {
4338 SetValueTypeName(ToUtf32("OperatorFunctionIdNode*"));
4339 }
4340 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4341 {
4342 parsingData->PushContext(Id(), new Context());
4343 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4344 }
4345 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4346 {
4347 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4348 if (matched)
4349 {
4350 stack.Push(UniquePtr<Object>(new ValueObject<OperatorFunctionIdNode*>(context->value)));
4351 }
4352 parsingData->PopContext(Id());
4353 }
4354 public override void Link()
4355 {
4356 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4357 a0ActionParser->SetAction(A0Action);
4358 NonterminalParser* operatorNonterminalParser = GetNonterminal(ToUtf32("Operator"));
4359 operatorNonterminalParser->SetPost(PostOperator);
4360 }
4361 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4362 {
4363 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4364 context->value = new OperatorFunctionIdNode(span, context->fromOperator);
4365 }
4366 public void PostOperator(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4367 {
4368 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4369 if (matched)
4370 {
4371 UniquePtr<Object> fromOperator_value = stack.Pop();
4372 context->fromOperator = *cast<ValueObject<Operator>*>(fromOperator_value.Get());
4373 }
4374 }
4375 public class Context : System.Text.Parsing.Context
4376 {
4377 public Context() : value(), fromOperator()
4378 {
4379 }
4380 public OperatorFunctionIdNode* value;
4381 public Operator fromOperator;
4382 }
4383 }
4384
4385 public class OperatorRule : System.Text.Parsing.RuleParser
4386 {
4387 public OperatorRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4388 {
4389 SetValueTypeName(ToUtf32("Operator"));
4390 }
4391 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4392 {
4393 parsingData->PushContext(Id(), new Context());
4394 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4395 }
4396 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4397 {
4398 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4399 if (matched)
4400 {
4401 stack.Push(UniquePtr<Object>(new ValueObject<Operator>(context->value)));
4402 }
4403 parsingData->PopContext(Id());
4404 }
4405 public override void Link()
4406 {
4407 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4408 a0ActionParser->SetAction(A0Action);
4409 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
4410 a1ActionParser->SetAction(A1Action);
4411 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
4412 a2ActionParser->SetAction(A2Action);
4413 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
4414 a3ActionParser->SetAction(A3Action);
4415 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
4416 a4ActionParser->SetAction(A4Action);
4417 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
4418 a5ActionParser->SetAction(A5Action);
4419 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
4420 a6ActionParser->SetAction(A6Action);
4421 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
4422 a7ActionParser->SetAction(A7Action);
4423 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
4424 a8ActionParser->SetAction(A8Action);
4425 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
4426 a9ActionParser->SetAction(A9Action);
4427 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
4428 a10ActionParser->SetAction(A10Action);
4429 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
4430 a11ActionParser->SetAction(A11Action);
4431 ActionParser* a12ActionParser = GetAction(ToUtf32("A12"));
4432 a12ActionParser->SetAction(A12Action);
4433 ActionParser* a13ActionParser = GetAction(ToUtf32("A13"));
4434 a13ActionParser->SetAction(A13Action);
4435 ActionParser* a14ActionParser = GetAction(ToUtf32("A14"));
4436 a14ActionParser->SetAction(A14Action);
4437 ActionParser* a15ActionParser = GetAction(ToUtf32("A15"));
4438 a15ActionParser->SetAction(A15Action);
4439 ActionParser* a16ActionParser = GetAction(ToUtf32("A16"));
4440 a16ActionParser->SetAction(A16Action);
4441 ActionParser* a17ActionParser = GetAction(ToUtf32("A17"));
4442 a17ActionParser->SetAction(A17Action);
4443 ActionParser* a18ActionParser = GetAction(ToUtf32("A18"));
4444 a18ActionParser->SetAction(A18Action);
4445 ActionParser* a19ActionParser = GetAction(ToUtf32("A19"));
4446 a19ActionParser->SetAction(A19Action);
4447 ActionParser* a20ActionParser = GetAction(ToUtf32("A20"));
4448 a20ActionParser->SetAction(A20Action);
4449 ActionParser* a21ActionParser = GetAction(ToUtf32("A21"));
4450 a21ActionParser->SetAction(A21Action);
4451 ActionParser* a22ActionParser = GetAction(ToUtf32("A22"));
4452 a22ActionParser->SetAction(A22Action);
4453 ActionParser* a23ActionParser = GetAction(ToUtf32("A23"));
4454 a23ActionParser->SetAction(A23Action);
4455 ActionParser* a24ActionParser = GetAction(ToUtf32("A24"));
4456 a24ActionParser->SetAction(A24Action);
4457 ActionParser* a25ActionParser = GetAction(ToUtf32("A25"));
4458 a25ActionParser->SetAction(A25Action);
4459 ActionParser* a26ActionParser = GetAction(ToUtf32("A26"));
4460 a26ActionParser->SetAction(A26Action);
4461 ActionParser* a27ActionParser = GetAction(ToUtf32("A27"));
4462 a27ActionParser->SetAction(A27Action);
4463 ActionParser* a28ActionParser = GetAction(ToUtf32("A28"));
4464 a28ActionParser->SetAction(A28Action);
4465 ActionParser* a29ActionParser = GetAction(ToUtf32("A29"));
4466 a29ActionParser->SetAction(A29Action);
4467 ActionParser* a30ActionParser = GetAction(ToUtf32("A30"));
4468 a30ActionParser->SetAction(A30Action);
4469 ActionParser* a31ActionParser = GetAction(ToUtf32("A31"));
4470 a31ActionParser->SetAction(A31Action);
4471 ActionParser* a32ActionParser = GetAction(ToUtf32("A32"));
4472 a32ActionParser->SetAction(A32Action);
4473 NonterminalParser* assignmentOperatorNonterminalParser = GetNonterminal(ToUtf32("AssignmentOperator"));
4474 assignmentOperatorNonterminalParser->SetPost(PostAssignmentOperator);
4475 }
4476 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4477 {
4478 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4479 context->value = Operator.arrayNew;
4480 }
4481 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4482 {
4483 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4484 context->value = Operator.arrayDelete;
4485 }
4486 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4487 {
4488 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4489 context->value = Operator.new_;
4490 }
4491 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4492 {
4493 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4494 context->value = Operator.delete_;
4495 }
4496 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4497 {
4498 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4499 context->value = context->fromAssignmentOperator;
4500 }
4501 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4502 {
4503 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4504 context->value = Operator.inc;
4505 }
4506 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4507 {
4508 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4509 context->value = Operator.dec;
4510 }
4511 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4512 {
4513 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4514 context->value = Operator.shiftLeft;
4515 }
4516 public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4517 {
4518 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4519 context->value = Operator.shiftRight;
4520 }
4521 public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4522 {
4523 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4524 context->value = Operator.logicalAnd;
4525 }
4526 public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4527 {
4528 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4529 context->value = Operator.logicalOr;
4530 }
4531 public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4532 {
4533 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4534 context->value = Operator.equal;
4535 }
4536 public void A12Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4537 {
4538 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4539 context->value = Operator.notEqual;
4540 }
4541 public void A13Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4542 {
4543 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4544 context->value = Operator.lessOrEqual;
4545 }
4546 public void A14Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4547 {
4548 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4549 context->value = Operator.greaterOrEqual;
4550 }
4551 public void A15Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4552 {
4553 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4554 context->value = Operator.dotStar;
4555 }
4556 public void A16Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4557 {
4558 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4559 context->value = Operator.arrowStar;
4560 }
4561 public void A17Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4562 {
4563 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4564 context->value = Operator.arrow;
4565 }
4566 public void A18Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4567 {
4568 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4569 context->value = Operator.apply;
4570 }
4571 public void A19Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4572 {
4573 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4574 context->value = Operator.subscript;
4575 }
4576 public void A20Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4577 {
4578 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4579 context->value = Operator.less;
4580 }
4581 public void A21Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4582 {
4583 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4584 context->value = Operator.greater;
4585 }
4586 public void A22Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4587 {
4588 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4589 context->value = Operator.add;
4590 }
4591 public void A23Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4592 {
4593 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4594 context->value = Operator.sub;
4595 }
4596 public void A24Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4597 {
4598 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4599 context->value = Operator.mul;
4600 }
4601 public void A25Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4602 {
4603 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4604 context->value = Operator.div;
4605 }
4606 public void A26Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4607 {
4608 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4609 context->value = Operator.rem;
4610 }
4611 public void A27Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4612 {
4613 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4614 context->value = Operator.xor;
4615 }
4616 public void A28Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4617 {
4618 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4619 context->value = Operator.and_;
4620 }
4621 public void A29Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4622 {
4623 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4624 context->value = Operator.or_;
4625 }
4626 public void A30Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4627 {
4628 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4629 context->value = Operator.neg;
4630 }
4631 public void A31Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4632 {
4633 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4634 context->value = Operator.not_;
4635 }
4636 public void A32Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4637 {
4638 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4639 context->value = Operator.comma;
4640 }
4641 public void PostAssignmentOperator(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4642 {
4643 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4644 if (matched)
4645 {
4646 UniquePtr<Object> fromAssignmentOperator_value = stack.Pop();
4647 context->fromAssignmentOperator = *cast<ValueObject<Operator>*>(fromAssignmentOperator_value.Get());
4648 }
4649 }
4650 public class Context : System.Text.Parsing.Context
4651 {
4652 public Context() : value(), fromAssignmentOperator()
4653 {
4654 }
4655 public Operator value;
4656 public Operator fromAssignmentOperator;
4657 }
4658 }
4659
4660 public class ConversionFunctionIdRule : System.Text.Parsing.RuleParser
4661 {
4662 public ConversionFunctionIdRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4663 {
4664 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
4665 SetValueTypeName(ToUtf32("ConversionFunctionIdNode*"));
4666 }
4667 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4668 {
4669 parsingData->PushContext(Id(), new Context());
4670 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4671 UniquePtr<Object> ctx_value = stack.Pop();
4672 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
4673 }
4674 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4675 {
4676 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4677 if (matched)
4678 {
4679 stack.Push(UniquePtr<Object>(new ValueObject<ConversionFunctionIdNode*>(context->value)));
4680 }
4681 parsingData->PopContext(Id());
4682 }
4683 public override void Link()
4684 {
4685 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4686 a0ActionParser->SetAction(A0Action);
4687 NonterminalParser* typeExprNonterminalParser = GetNonterminal(ToUtf32("TypeExpr"));
4688 typeExprNonterminalParser->SetPre(PreTypeExpr);
4689 typeExprNonterminalParser->SetPost(PostTypeExpr);
4690 }
4691 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4692 {
4693 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4694 context->value = new ConversionFunctionIdNode(span, context->fromTypeExpr);
4695 }
4696 public void PreTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4697 {
4698 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4699 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4700 }
4701 public void PostTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4702 {
4703 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4704 if (matched)
4705 {
4706 UniquePtr<Object> fromTypeExpr_value = stack.Pop();
4707 context->fromTypeExpr = *cast<ValueObject<Node*>*>(fromTypeExpr_value.Get());
4708 }
4709 }
4710 public class Context : System.Text.Parsing.Context
4711 {
4712 public Context() : ctx(), value(), fromTypeExpr()
4713 {
4714 }
4715 public ParsingContext* ctx;
4716 public ConversionFunctionIdNode* value;
4717 public Node* fromTypeExpr;
4718 }
4719 }
4720
4721 public class LambdaExpressionRule : System.Text.Parsing.RuleParser
4722 {
4723 public LambdaExpressionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4724 {
4725 AddInheritedAttribute(AttrOrVar(ToUtf32("ParsingContext*"), ToUtf32("ctx")));
4726 SetValueTypeName(ToUtf32("LambdaExpressionNode*"));
4727 }
4728 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4729 {
4730 parsingData->PushContext(Id(), new Context());
4731 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4732 UniquePtr<Object> ctx_value = stack.Pop();
4733 context->ctx = *cast<ValueObject<ParsingContext*>*>(ctx_value.Get());
4734 }
4735 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4736 {
4737 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4738 if (matched)
4739 {
4740 stack.Push(UniquePtr<Object>(new ValueObject<LambdaExpressionNode*>(context->value)));
4741 }
4742 parsingData->PopContext(Id());
4743 }
4744 public override void Link()
4745 {
4746 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4747 a0ActionParser->SetAction(A0Action);
4748 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
4749 a1ActionParser->SetAction(A1Action);
4750 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
4751 a2ActionParser->SetAction(A2Action);
4752 NonterminalParser* lambdaCapturesNonterminalParser = GetNonterminal(ToUtf32("LambdaCaptures"));
4753 lambdaCapturesNonterminalParser->SetPre(PreLambdaCaptures);
4754 NonterminalParser* parameterListNonterminalParser = GetNonterminal(ToUtf32("ParameterList"));
4755 parameterListNonterminalParser->SetPre(PreParameterList);
4756 parameterListNonterminalParser->SetPost(PostParameterList);
4757 NonterminalParser* compoundStatementNonterminalParser = GetNonterminal(ToUtf32("CompoundStatement"));
4758 compoundStatementNonterminalParser->SetPre(PreCompoundStatement);
4759 compoundStatementNonterminalParser->SetPost(PostCompoundStatement);
4760 }
4761 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4762 {
4763 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4764 context->value = new LambdaExpressionNode(span);
4765 }
4766 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4767 {
4768 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4769 context->value->SetParameters(context->fromParameterList);
4770 }
4771 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4772 {
4773 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4774 context->value->SetBody(context->fromCompoundStatement);
4775 }
4776 public void PreLambdaCaptures(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4777 {
4778 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4779 stack.Push(UniquePtr<Object>(new ValueObject<LambdaExpressionNode*>(context->value)));
4780 }
4781 public void PreParameterList(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4782 {
4783 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4784 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4785 }
4786 public void PostParameterList(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4787 {
4788 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4789 if (matched)
4790 {
4791 UniquePtr<Object> fromParameterList_value = stack.Pop();
4792 context->fromParameterList = *cast<ValueObject<ParameterListNode*>*>(fromParameterList_value.Get());
4793 }
4794 }
4795 public void PreCompoundStatement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4796 {
4797 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4798 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(context->ctx)));
4799 }
4800 public void PostCompoundStatement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4801 {
4802 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4803 if (matched)
4804 {
4805 UniquePtr<Object> fromCompoundStatement_value = stack.Pop();
4806 context->fromCompoundStatement = *cast<ValueObject<CompoundStatementNode*>*>(fromCompoundStatement_value.Get());
4807 }
4808 }
4809 public class Context : System.Text.Parsing.Context
4810 {
4811 public Context() : ctx(), value(), fromParameterList(), fromCompoundStatement()
4812 {
4813 }
4814 public ParsingContext* ctx;
4815 public LambdaExpressionNode* value;
4816 public ParameterListNode* fromParameterList;
4817 public CompoundStatementNode* fromCompoundStatement;
4818 }
4819 }
4820
4821 public class LambdaCapturesRule : System.Text.Parsing.RuleParser
4822 {
4823 public LambdaCapturesRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4824 {
4825 AddInheritedAttribute(AttrOrVar(ToUtf32("LambdaExpressionNode*"), ToUtf32("lambdaExpression")));
4826 }
4827 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4828 {
4829 parsingData->PushContext(Id(), new Context());
4830 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4831 UniquePtr<Object> lambdaExpression_value = stack.Pop();
4832 context->lambdaExpression = *cast<ValueObject<LambdaExpressionNode*>*>(lambdaExpression_value.Get());
4833 }
4834 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4835 {
4836 parsingData->PopContext(Id());
4837 }
4838 public override void Link()
4839 {
4840 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4841 a0ActionParser->SetAction(A0Action);
4842 NonterminalParser* captureDefaultNonterminalParser = GetNonterminal(ToUtf32("CaptureDefault"));
4843 captureDefaultNonterminalParser->SetPost(PostCaptureDefault);
4844 NonterminalParser* capturesNonterminalParser = GetNonterminal(ToUtf32("Captures"));
4845 capturesNonterminalParser->SetPre(PreCaptures);
4846 }
4847 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4848 {
4849 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4850 context->lambdaExpression->AddCapture(context->fromCaptureDefault);
4851 }
4852 public void PostCaptureDefault(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4853 {
4854 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4855 if (matched)
4856 {
4857 UniquePtr<Object> fromCaptureDefault_value = stack.Pop();
4858 context->fromCaptureDefault = *cast<ValueObject<Node*>*>(fromCaptureDefault_value.Get());
4859 }
4860 }
4861 public void PreCaptures(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4862 {
4863 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4864 stack.Push(UniquePtr<Object>(new ValueObject<LambdaExpressionNode*>(context->lambdaExpression)));
4865 }
4866 public class Context : System.Text.Parsing.Context
4867 {
4868 public Context() : lambdaExpression(), fromCaptureDefault()
4869 {
4870 }
4871 public LambdaExpressionNode* lambdaExpression;
4872 public Node* fromCaptureDefault;
4873 }
4874 }
4875
4876 public class CaptureDefaultRule : System.Text.Parsing.RuleParser
4877 {
4878 public CaptureDefaultRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4879 {
4880 SetValueTypeName(ToUtf32("Node*"));
4881 }
4882 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4883 {
4884 parsingData->PushContext(Id(), new Context());
4885 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4886 }
4887 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4888 {
4889 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4890 if (matched)
4891 {
4892 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
4893 }
4894 parsingData->PopContext(Id());
4895 }
4896 public override void Link()
4897 {
4898 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4899 a0ActionParser->SetAction(A0Action);
4900 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
4901 a1ActionParser->SetAction(A1Action);
4902 }
4903 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4904 {
4905 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4906 context->value = new AssignCapture(span);
4907 }
4908 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4909 {
4910 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4911 context->value = new RefCapture(span);
4912 }
4913 public class Context : System.Text.Parsing.Context
4914 {
4915 public Context() : value()
4916 {
4917 }
4918 public Node* value;
4919 }
4920 }
4921
4922 public class CapturesRule : System.Text.Parsing.RuleParser
4923 {
4924 public CapturesRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4925 {
4926 AddInheritedAttribute(AttrOrVar(ToUtf32("LambdaExpressionNode*"), ToUtf32("lambdaExpression")));
4927 }
4928 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4929 {
4930 parsingData->PushContext(Id(), new Context());
4931 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4932 UniquePtr<Object> lambdaExpression_value = stack.Pop();
4933 context->lambdaExpression = *cast<ValueObject<LambdaExpressionNode*>*>(lambdaExpression_value.Get());
4934 }
4935 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4936 {
4937 parsingData->PopContext(Id());
4938 }
4939 public override void Link()
4940 {
4941 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4942 a0ActionParser->SetAction(A0Action);
4943 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
4944 a1ActionParser->SetAction(A1Action);
4945 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
4946 leftNonterminalParser->SetPost(Postleft);
4947 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
4948 rightNonterminalParser->SetPost(Postright);
4949 }
4950 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4951 {
4952 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4953 context->lambdaExpression->AddCapture(context->fromleft);
4954 }
4955 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4956 {
4957 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4958 context->lambdaExpression->AddCapture(context->fromright);
4959 }
4960 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4961 {
4962 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4963 if (matched)
4964 {
4965 UniquePtr<Object> fromleft_value = stack.Pop();
4966 context->fromleft = *cast<ValueObject<Node*>*>(fromleft_value.Get());
4967 }
4968 }
4969 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4970 {
4971 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4972 if (matched)
4973 {
4974 UniquePtr<Object> fromright_value = stack.Pop();
4975 context->fromright = *cast<ValueObject<Node*>*>(fromright_value.Get());
4976 }
4977 }
4978 public class Context : System.Text.Parsing.Context
4979 {
4980 public Context() : lambdaExpression(), fromleft(), fromright()
4981 {
4982 }
4983 public LambdaExpressionNode* lambdaExpression;
4984 public Node* fromleft;
4985 public Node* fromright;
4986 }
4987 }
4988
4989 public class CaptureRule : System.Text.Parsing.RuleParser
4990 {
4991 public CaptureRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4992 {
4993 SetValueTypeName(ToUtf32("Node*"));
4994 }
4995 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4996 {
4997 parsingData->PushContext(Id(), new Context());
4998 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4999 }
5000 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5001 {
5002 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5003 if (matched)
5004 {
5005 stack.Push(UniquePtr<Object>(new ValueObject<Node*>(context->value)));
5006 }
5007 parsingData->PopContext(Id());
5008 }
5009 public override void Link()
5010 {
5011 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5012 a0ActionParser->SetAction(A0Action);
5013 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
5014 a1ActionParser->SetAction(A1Action);
5015 NonterminalParser* identifierNonterminalParser = GetNonterminal(ToUtf32("Identifier"));
5016 identifierNonterminalParser->SetPost(PostIdentifier);
5017 }
5018 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5019 {
5020 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5021 context->value = new IdentifierCapture(span, context->fromIdentifier);
5022 }
5023 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5024 {
5025 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5026 context->value = new ThisCapture(span);
5027 }
5028 public void PostIdentifier(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5029 {
5030 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5031 if (matched)
5032 {
5033 UniquePtr<Object> fromIdentifier_value = stack.Pop();
5034 context->fromIdentifier = *cast<ValueObject<IdentifierNode*>*>(fromIdentifier_value.Get());
5035 }
5036 }
5037 public class Context : System.Text.Parsing.Context
5038 {
5039 public Context() : value(), fromIdentifier()
5040 {
5041 }
5042 public Node* value;
5043 public IdentifierNode* fromIdentifier;
5044 }
5045 }
5046
5047 public override void GetReferencedGrammars()
5048 {
5049 ParsingDomain* pd = Domain();
5050 Grammar* grammar0 = pd->GetGrammar(ToUtf32("cppparser.FunctionGrammar"));
5051 if (grammar0 == null)
5052 {
5053 grammar0 = new cppparser.FunctionGrammar(pd);
5054 }
5055 AddGrammarReference(grammar0);
5056 Grammar* grammar1 = pd->GetGrammar(ToUtf32("cppparser.TemplateGrammar"));
5057 if (grammar1 == null)
5058 {
5059 grammar1 = new cppparser.TemplateGrammar(pd);
5060 }
5061 AddGrammarReference(grammar1);
5062 Grammar* grammar2 = pd->GetGrammar(ToUtf32("cppparser.StatementGrammar"));
5063 if (grammar2 == null)
5064 {
5065 grammar2 = new cppparser.StatementGrammar(pd);
5066 }
5067 AddGrammarReference(grammar2);
5068 Grammar* grammar3 = pd->GetGrammar(ToUtf32("cppparser.IdentifierGrammar"));
5069 if (grammar3 == null)
5070 {
5071 grammar3 = new cppparser.IdentifierGrammar(pd);
5072 }
5073 AddGrammarReference(grammar3);
5074 Grammar* grammar4 = pd->GetGrammar(ToUtf32("System.Text.Parsing.stdlib"));
5075 if (grammar4 == null)
5076 {
5077 grammar4 = new System.Text.Parsing.stdlib(pd);
5078 }
5079 AddGrammarReference(grammar4);
5080 Grammar* grammar5 = pd->GetGrammar(ToUtf32("cppparser.TypeExprGrammar"));
5081 if (grammar5 == null)
5082 {
5083 grammar5 = new cppparser.TypeExprGrammar(pd);
5084 }
5085 AddGrammarReference(grammar5);
5086 Grammar* grammar6 = pd->GetGrammar(ToUtf32("cppparser.DeclaratorGrammar"));
5087 if (grammar6 == null)
5088 {
5089 grammar6 = new cppparser.DeclaratorGrammar(pd);
5090 }
5091 AddGrammarReference(grammar6);
5092 Grammar* grammar7 = pd->GetGrammar(ToUtf32("cppparser.SimpleTypeGrammar"));
5093 if (grammar7 == null)
5094 {
5095 grammar7 = new cppparser.SimpleTypeGrammar(pd);
5096 }
5097 AddGrammarReference(grammar7);
5098 Grammar* grammar8 = pd->GetGrammar(ToUtf32("cppparser.LiteralGrammar"));
5099 if (grammar8 == null)
5100 {
5101 grammar8 = new cppparser.LiteralGrammar(pd);
5102 }
5103 AddGrammarReference(grammar8);
5104 }
5105 public override void CreateRules()
5106 {
5107 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("InitializerList"), this, ToUtf32("DeclaratorGrammar.InitializerList")));
5108 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("InitializerClause"), this, ToUtf32("DeclaratorGrammar.InitializerClause")));
5109 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("BracedInitializerList"), this, ToUtf32("DeclaratorGrammar.BracedInitializerList")));
5110 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("TypeExpr"), this, ToUtf32("TypeExprGrammar.TypeExpr")));
5111 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("SimpleType"), this, ToUtf32("SimpleTypeGrammar.SimpleType")));
5112 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("Literal"), this, ToUtf32("LiteralGrammar.Literal")));
5113 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("SimpleTypeSpecifier"), this, ToUtf32("SimpleTypeGrammar.SimpleTypeSpecifier")));
5114 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("TemplateId"), this, ToUtf32("TemplateGrammar.TemplateId")));
5115 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("Identifier"), this, ToUtf32("IdentifierGrammar.Identifier")));
5116 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("NestedNameSpecifier"), this, ToUtf32("IdentifierGrammar.NestedNameSpecifier")));
5117 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("ParameterList"), this, ToUtf32("FunctionGrammar.ParameterList")));
5118 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("CompoundStatement"), this, ToUtf32("StatementGrammar.CompoundStatement")));
5119 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("identifier"), this, ToUtf32("System.Text.Parsing.stdlib.identifier")));
5120 AddRule(new ExpressionListRule(ToUtf32("ExpressionList"), GetScope(), Domain()->GetNextRuleId(),
5121 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5122 new System.Text.Parsing.GroupingParser(
5123 new System.Text.Parsing.SequenceParser(
5124 new System.Text.Parsing.SequenceParser(
5125 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5126 new System.Text.Parsing.EmptyParser()),
5127 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5128 new System.Text.Parsing.NonterminalParser(ToUtf32("ic1"), ToUtf32("InitializerClause"), 1))),
5129 new System.Text.Parsing.KleeneStarParser(
5130 new System.Text.Parsing.GroupingParser(
5131 new System.Text.Parsing.SequenceParser(
5132 new System.Text.Parsing.CharParser(','),
5133 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5134 new System.Text.Parsing.NonterminalParser(ToUtf32("ic2"), ToUtf32("InitializerClause"), 1))))))))));
5135 AddRule(new PossiblyEmptyArgumentListRule(ToUtf32("PossiblyEmptyArgumentList"), GetScope(), Domain()->GetNextRuleId(),
5136 new System.Text.Parsing.AlternativeParser(
5137 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5138 new System.Text.Parsing.NonterminalParser(ToUtf32("ExpressionList"), ToUtf32("ExpressionList"), 1)),
5139 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5140 new System.Text.Parsing.EmptyParser()))));
5141 AddRule(new ExpressionRule(ToUtf32("Expression"), GetScope(), Domain()->GetNextRuleId(),
5142 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5143 new System.Text.Parsing.GroupingParser(
5144 new System.Text.Parsing.SequenceParser(
5145 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5146 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("AssignmentExpression"), 1)),
5147 new System.Text.Parsing.KleeneStarParser(
5148 new System.Text.Parsing.GroupingParser(
5149 new System.Text.Parsing.SequenceParser(
5150 new System.Text.Parsing.CharParser(','),
5151 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5152 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("AssignmentExpression"), 1))))))))));
5153 AddRule(new ConstantExpressionRule(ToUtf32("ConstantExpression"), GetScope(), Domain()->GetNextRuleId(),
5154 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5155 new System.Text.Parsing.NonterminalParser(ToUtf32("ConditionalExpression"), ToUtf32("ConditionalExpression"), 1))));
5156 AddRule(new AssignmentExpressionRule(ToUtf32("AssignmentExpression"), GetScope(), Domain()->GetNextRuleId(),
5157 new System.Text.Parsing.AlternativeParser(
5158 new System.Text.Parsing.AlternativeParser(
5159 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5160 new System.Text.Parsing.NonterminalParser(ToUtf32("ConcreteAssignmentExpression"), ToUtf32("ConcreteAssignmentExpression"), 1)),
5161 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5162 new System.Text.Parsing.NonterminalParser(ToUtf32("ConditionalExpression"), ToUtf32("ConditionalExpression"), 1))),
5163 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5164 new System.Text.Parsing.NonterminalParser(ToUtf32("ThrowExpression"), ToUtf32("ThrowExpression"), 1)))));
5165 AddRule(new ConcreteAssignmentExpressionRule(ToUtf32("ConcreteAssignmentExpression"), GetScope(), Domain()->GetNextRuleId(),
5166 new System.Text.Parsing.SequenceParser(
5167 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5168 new System.Text.Parsing.EmptyParser()),
5169 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5170 new System.Text.Parsing.GroupingParser(
5171 new System.Text.Parsing.SequenceParser(
5172 new System.Text.Parsing.SequenceParser(
5173 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5174 new System.Text.Parsing.NonterminalParser(ToUtf32("LogicalOrExpression"), ToUtf32("LogicalOrExpression"), 1)),
5175 new System.Text.Parsing.NonterminalParser(ToUtf32("AssignmentOperator"), ToUtf32("AssignmentOperator"), 0)),
5176 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5177 new System.Text.Parsing.NonterminalParser(ToUtf32("InitializerClause"), ToUtf32("InitializerClause"), 1))))))));
5178 AddRule(new AssignmentOperatorRule(ToUtf32("AssignmentOperator"), GetScope(), Domain()->GetNextRuleId(),
5179 new System.Text.Parsing.AlternativeParser(
5180 new System.Text.Parsing.AlternativeParser(
5181 new System.Text.Parsing.AlternativeParser(
5182 new System.Text.Parsing.AlternativeParser(
5183 new System.Text.Parsing.AlternativeParser(
5184 new System.Text.Parsing.AlternativeParser(
5185 new System.Text.Parsing.AlternativeParser(
5186 new System.Text.Parsing.AlternativeParser(
5187 new System.Text.Parsing.AlternativeParser(
5188 new System.Text.Parsing.AlternativeParser(
5189 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5190 new System.Text.Parsing.GroupingParser(
5191 new System.Text.Parsing.DifferenceParser(
5192 new System.Text.Parsing.StringParser(ToUtf32("=")),
5193 new System.Text.Parsing.StringParser(ToUtf32("=="))))),
5194 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5195 new System.Text.Parsing.StringParser(ToUtf32("*=")))),
5196 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5197 new System.Text.Parsing.StringParser(ToUtf32("/=")))),
5198 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5199 new System.Text.Parsing.StringParser(ToUtf32("%=")))),
5200 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
5201 new System.Text.Parsing.StringParser(ToUtf32("+=")))),
5202 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
5203 new System.Text.Parsing.StringParser(ToUtf32("-=")))),
5204 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
5205 new System.Text.Parsing.StringParser(ToUtf32(">>=")))),
5206 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
5207 new System.Text.Parsing.StringParser(ToUtf32("<<=")))),
5208 new System.Text.Parsing.ActionParser(ToUtf32("A8"),
5209 new System.Text.Parsing.StringParser(ToUtf32("&=")))),
5210 new System.Text.Parsing.ActionParser(ToUtf32("A9"),
5211 new System.Text.Parsing.StringParser(ToUtf32("^=")))),
5212 new System.Text.Parsing.ActionParser(ToUtf32("A10"),
5213 new System.Text.Parsing.StringParser(ToUtf32("|="))))));
5214 AddRule(new ConditionalExpressionRule(ToUtf32("ConditionalExpression"), GetScope(), Domain()->GetNextRuleId(),
5215 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5216 new System.Text.Parsing.GroupingParser(
5217 new System.Text.Parsing.SequenceParser(
5218 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5219 new System.Text.Parsing.NonterminalParser(ToUtf32("LogicalOrExpression"), ToUtf32("LogicalOrExpression"), 1)),
5220 new System.Text.Parsing.OptionalParser(
5221 new System.Text.Parsing.GroupingParser(
5222 new System.Text.Parsing.SequenceParser(
5223 new System.Text.Parsing.SequenceParser(
5224 new System.Text.Parsing.SequenceParser(
5225 new System.Text.Parsing.CharParser('?'),
5226 new System.Text.Parsing.NonterminalParser(ToUtf32("Expression"), ToUtf32("Expression"), 1)),
5227 new System.Text.Parsing.CharParser(':')),
5228 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5229 new System.Text.Parsing.NonterminalParser(ToUtf32("AssignmentExpression"), ToUtf32("AssignmentExpression"), 1))))))))));
5230 AddRule(new ThrowExpressionRule(ToUtf32("ThrowExpression"), GetScope(), Domain()->GetNextRuleId(),
5231 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5232 new System.Text.Parsing.GroupingParser(
5233 new System.Text.Parsing.SequenceParser(
5234 new System.Text.Parsing.KeywordParser(ToUtf32("throw")),
5235 new System.Text.Parsing.OptionalParser(
5236 new System.Text.Parsing.NonterminalParser(ToUtf32("AssignmentExpression"), ToUtf32("AssignmentExpression"), 1)))))));
5237 AddRule(new LogicalOrExpressionRule(ToUtf32("LogicalOrExpression"), GetScope(), Domain()->GetNextRuleId(),
5238 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5239 new System.Text.Parsing.GroupingParser(
5240 new System.Text.Parsing.SequenceParser(
5241 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5242 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("LogicalAndExpression"), 1)),
5243 new System.Text.Parsing.KleeneStarParser(
5244 new System.Text.Parsing.GroupingParser(
5245 new System.Text.Parsing.SequenceParser(
5246 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5247 new System.Text.Parsing.StringParser(ToUtf32("||"))),
5248 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5249 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("LogicalAndExpression"), 1))))))))));
5250 AddRule(new LogicalAndExpressionRule(ToUtf32("LogicalAndExpression"), GetScope(), Domain()->GetNextRuleId(),
5251 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5252 new System.Text.Parsing.GroupingParser(
5253 new System.Text.Parsing.SequenceParser(
5254 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5255 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("InclusiveOrExpression"), 1)),
5256 new System.Text.Parsing.KleeneStarParser(
5257 new System.Text.Parsing.GroupingParser(
5258 new System.Text.Parsing.SequenceParser(
5259 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5260 new System.Text.Parsing.StringParser(ToUtf32("&&"))),
5261 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5262 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("InclusiveOrExpression"), 1))))))))));
5263 AddRule(new InclusiveOrExpressionRule(ToUtf32("InclusiveOrExpression"), GetScope(), Domain()->GetNextRuleId(),
5264 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5265 new System.Text.Parsing.GroupingParser(
5266 new System.Text.Parsing.SequenceParser(
5267 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5268 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("ExclusiveOrExpression"), 1)),
5269 new System.Text.Parsing.KleeneStarParser(
5270 new System.Text.Parsing.GroupingParser(
5271 new System.Text.Parsing.SequenceParser(
5272 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5273 new System.Text.Parsing.GroupingParser(
5274 new System.Text.Parsing.DifferenceParser(
5275 new System.Text.Parsing.CharParser('|'),
5276 new System.Text.Parsing.GroupingParser(
5277 new System.Text.Parsing.AlternativeParser(
5278 new System.Text.Parsing.StringParser(ToUtf32("|=")),
5279 new System.Text.Parsing.StringParser(ToUtf32("||"))))))),
5280 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5281 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("ExclusiveOrExpression"), 1))))))))));
5282 AddRule(new ExclusiveOrExpressionRule(ToUtf32("ExclusiveOrExpression"), GetScope(), Domain()->GetNextRuleId(),
5283 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5284 new System.Text.Parsing.GroupingParser(
5285 new System.Text.Parsing.SequenceParser(
5286 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5287 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("AndExpression"), 1)),
5288 new System.Text.Parsing.KleeneStarParser(
5289 new System.Text.Parsing.GroupingParser(
5290 new System.Text.Parsing.SequenceParser(
5291 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5292 new System.Text.Parsing.GroupingParser(
5293 new System.Text.Parsing.DifferenceParser(
5294 new System.Text.Parsing.CharParser('^'),
5295 new System.Text.Parsing.StringParser(ToUtf32("^="))))),
5296 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5297 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("AndExpression"), 1))))))))));
5298 AddRule(new AndExpressionRule(ToUtf32("AndExpression"), GetScope(), Domain()->GetNextRuleId(),
5299 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5300 new System.Text.Parsing.GroupingParser(
5301 new System.Text.Parsing.SequenceParser(
5302 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5303 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("EqualityExpression"), 1)),
5304 new System.Text.Parsing.KleeneStarParser(
5305 new System.Text.Parsing.GroupingParser(
5306 new System.Text.Parsing.SequenceParser(
5307 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5308 new System.Text.Parsing.GroupingParser(
5309 new System.Text.Parsing.DifferenceParser(
5310 new System.Text.Parsing.CharParser('&'),
5311 new System.Text.Parsing.GroupingParser(
5312 new System.Text.Parsing.AlternativeParser(
5313 new System.Text.Parsing.StringParser(ToUtf32("&=")),
5314 new System.Text.Parsing.StringParser(ToUtf32("&&"))))))),
5315 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5316 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("EqualityExpression"), 1))))))))));
5317 AddRule(new EqualityExpressionRule(ToUtf32("EqualityExpression"), GetScope(), Domain()->GetNextRuleId(),
5318 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5319 new System.Text.Parsing.GroupingParser(
5320 new System.Text.Parsing.SequenceParser(
5321 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5322 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("RelationalExpression"), 1)),
5323 new System.Text.Parsing.KleeneStarParser(
5324 new System.Text.Parsing.GroupingParser(
5325 new System.Text.Parsing.SequenceParser(
5326 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5327 new System.Text.Parsing.GroupingParser(
5328 new System.Text.Parsing.AlternativeParser(
5329 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5330 new System.Text.Parsing.StringParser(ToUtf32("=="))),
5331 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
5332 new System.Text.Parsing.StringParser(ToUtf32("!=")))))),
5333 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
5334 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("RelationalExpression"), 1))))))))));
5335 AddRule(new RelationalExpressionRule(ToUtf32("RelationalExpression"), GetScope(), Domain()->GetNextRuleId(),
5336 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5337 new System.Text.Parsing.GroupingParser(
5338 new System.Text.Parsing.SequenceParser(
5339 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5340 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("ShiftExpression"), 1)),
5341 new System.Text.Parsing.KleeneStarParser(
5342 new System.Text.Parsing.GroupingParser(
5343 new System.Text.Parsing.SequenceParser(
5344 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5345 new System.Text.Parsing.GroupingParser(
5346 new System.Text.Parsing.AlternativeParser(
5347 new System.Text.Parsing.AlternativeParser(
5348 new System.Text.Parsing.AlternativeParser(
5349 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5350 new System.Text.Parsing.StringParser(ToUtf32("<="))),
5351 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
5352 new System.Text.Parsing.StringParser(ToUtf32(">=")))),
5353 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
5354 new System.Text.Parsing.GroupingParser(
5355 new System.Text.Parsing.DifferenceParser(
5356 new System.Text.Parsing.CharParser('<'),
5357 new System.Text.Parsing.GroupingParser(
5358 new System.Text.Parsing.AlternativeParser(
5359 new System.Text.Parsing.StringParser(ToUtf32("<<")),
5360 new System.Text.Parsing.StringParser(ToUtf32("<<=")))))))),
5361 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
5362 new System.Text.Parsing.GroupingParser(
5363 new System.Text.Parsing.DifferenceParser(
5364 new System.Text.Parsing.CharParser('>'),
5365 new System.Text.Parsing.GroupingParser(
5366 new System.Text.Parsing.AlternativeParser(
5367 new System.Text.Parsing.StringParser(ToUtf32(">>")),
5368 new System.Text.Parsing.StringParser(ToUtf32(">>=")))))))))),
5369 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
5370 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("ShiftExpression"), 1))))))))));
5371 AddRule(new ShiftExpressionRule(ToUtf32("ShiftExpression"), GetScope(), Domain()->GetNextRuleId(),
5372 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5373 new System.Text.Parsing.GroupingParser(
5374 new System.Text.Parsing.SequenceParser(
5375 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5376 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("AdditiveExpression"), 1)),
5377 new System.Text.Parsing.KleeneStarParser(
5378 new System.Text.Parsing.GroupingParser(
5379 new System.Text.Parsing.SequenceParser(
5380 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5381 new System.Text.Parsing.GroupingParser(
5382 new System.Text.Parsing.AlternativeParser(
5383 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5384 new System.Text.Parsing.GroupingParser(
5385 new System.Text.Parsing.DifferenceParser(
5386 new System.Text.Parsing.StringParser(ToUtf32("<<")),
5387 new System.Text.Parsing.StringParser(ToUtf32("<<="))))),
5388 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
5389 new System.Text.Parsing.GroupingParser(
5390 new System.Text.Parsing.DifferenceParser(
5391 new System.Text.Parsing.StringParser(ToUtf32(">>")),
5392 new System.Text.Parsing.StringParser(ToUtf32(">>=")))))))),
5393 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
5394 new System.Text.Parsing.GroupingParser(
5395 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("AdditiveExpression"), 1)))))))))));
5396 AddRule(new AdditiveExpressionRule(ToUtf32("AdditiveExpression"), GetScope(), Domain()->GetNextRuleId(),
5397 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5398 new System.Text.Parsing.GroupingParser(
5399 new System.Text.Parsing.SequenceParser(
5400 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5401 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("MultiplicativeExpression"), 1)),
5402 new System.Text.Parsing.KleeneStarParser(
5403 new System.Text.Parsing.GroupingParser(
5404 new System.Text.Parsing.SequenceParser(
5405 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5406 new System.Text.Parsing.GroupingParser(
5407 new System.Text.Parsing.AlternativeParser(
5408 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5409 new System.Text.Parsing.GroupingParser(
5410 new System.Text.Parsing.DifferenceParser(
5411 new System.Text.Parsing.CharParser('+'),
5412 new System.Text.Parsing.StringParser(ToUtf32("+="))))),
5413 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
5414 new System.Text.Parsing.GroupingParser(
5415 new System.Text.Parsing.DifferenceParser(
5416 new System.Text.Parsing.CharParser('-'),
5417 new System.Text.Parsing.StringParser(ToUtf32("-=")))))))),
5418 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
5419 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("MultiplicativeExpression"), 1))))))))));
5420 AddRule(new MultiplicativeExpressionRule(ToUtf32("MultiplicativeExpression"), GetScope(), Domain()->GetNextRuleId(),
5421 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5422 new System.Text.Parsing.GroupingParser(
5423 new System.Text.Parsing.SequenceParser(
5424 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5425 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("PMExpression"), 1)),
5426 new System.Text.Parsing.KleeneStarParser(
5427 new System.Text.Parsing.GroupingParser(
5428 new System.Text.Parsing.SequenceParser(
5429 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5430 new System.Text.Parsing.GroupingParser(
5431 new System.Text.Parsing.AlternativeParser(
5432 new System.Text.Parsing.AlternativeParser(
5433 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5434 new System.Text.Parsing.GroupingParser(
5435 new System.Text.Parsing.DifferenceParser(
5436 new System.Text.Parsing.CharParser('*'),
5437 new System.Text.Parsing.StringParser(ToUtf32("*="))))),
5438 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
5439 new System.Text.Parsing.GroupingParser(
5440 new System.Text.Parsing.DifferenceParser(
5441 new System.Text.Parsing.CharParser('/'),
5442 new System.Text.Parsing.StringParser(ToUtf32("/=")))))),
5443 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
5444 new System.Text.Parsing.GroupingParser(
5445 new System.Text.Parsing.DifferenceParser(
5446 new System.Text.Parsing.CharParser('%'),
5447 new System.Text.Parsing.StringParser(ToUtf32("%=")))))))),
5448 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
5449 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("PMExpression"), 1))))))))));
5450 AddRule(new PMExpressionRule(ToUtf32("PMExpression"), GetScope(), Domain()->GetNextRuleId(),
5451 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5452 new System.Text.Parsing.GroupingParser(
5453 new System.Text.Parsing.SequenceParser(
5454 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5455 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("CastExpression"), 1)),
5456 new System.Text.Parsing.KleeneStarParser(
5457 new System.Text.Parsing.GroupingParser(
5458 new System.Text.Parsing.SequenceParser(
5459 new System.Text.Parsing.GroupingParser(
5460 new System.Text.Parsing.AlternativeParser(
5461 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5462 new System.Text.Parsing.StringParser(ToUtf32(".*"))),
5463 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5464 new System.Text.Parsing.StringParser(ToUtf32("->*"))))),
5465 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
5466 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("CastExpression"), 1))))))))));
5467 AddRule(new CastExpressionRule(ToUtf32("CastExpression"), GetScope(), Domain()->GetNextRuleId(),
5468 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5469 new System.Text.Parsing.GroupingParser(
5470 new System.Text.Parsing.AlternativeParser(
5471 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5472 new System.Text.Parsing.GroupingParser(
5473 new System.Text.Parsing.SequenceParser(
5474 new System.Text.Parsing.SequenceParser(
5475 new System.Text.Parsing.SequenceParser(
5476 new System.Text.Parsing.CharParser('('),
5477 new System.Text.Parsing.NonterminalParser(ToUtf32("TypeExpr"), ToUtf32("TypeExpr"), 1)),
5478 new System.Text.Parsing.CharParser(')')),
5479 new System.Text.Parsing.NonterminalParser(ToUtf32("CastExpression"), ToUtf32("CastExpression"), 1)))),
5480 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5481 new System.Text.Parsing.NonterminalParser(ToUtf32("UnaryExpression"), ToUtf32("UnaryExpression"), 1)))))));
5482 AddRule(new UnaryExpressionRule(ToUtf32("UnaryExpression"), GetScope(), Domain()->GetNextRuleId(),
5483 new System.Text.Parsing.AlternativeParser(
5484 new System.Text.Parsing.AlternativeParser(
5485 new System.Text.Parsing.AlternativeParser(
5486 new System.Text.Parsing.AlternativeParser(
5487 new System.Text.Parsing.AlternativeParser(
5488 new System.Text.Parsing.AlternativeParser(
5489 new System.Text.Parsing.AlternativeParser(
5490 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5491 new System.Text.Parsing.GroupingParser(
5492 new System.Text.Parsing.SequenceParser(
5493 new System.Text.Parsing.StringParser(ToUtf32("++")),
5494 new System.Text.Parsing.NonterminalParser(ToUtf32("c1"), ToUtf32("CastExpression"), 1)))),
5495 new System.Text.Parsing.SequenceParser(
5496 new System.Text.Parsing.StringParser(ToUtf32("--")),
5497 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5498 new System.Text.Parsing.NonterminalParser(ToUtf32("c2"), ToUtf32("CastExpression"), 1)))),
5499 new System.Text.Parsing.SequenceParser(
5500 new System.Text.Parsing.NonterminalParser(ToUtf32("op"), ToUtf32("UnaryOperator"), 0),
5501 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5502 new System.Text.Parsing.NonterminalParser(ToUtf32("c3"), ToUtf32("CastExpression"), 1)))),
5503 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5504 new System.Text.Parsing.GroupingParser(
5505 new System.Text.Parsing.SequenceParser(
5506 new System.Text.Parsing.KeywordParser(ToUtf32("sizeof")),
5507 new System.Text.Parsing.NonterminalParser(ToUtf32("u4"), ToUtf32("UnaryExpression"), 1))))),
5508 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
5509 new System.Text.Parsing.GroupingParser(
5510 new System.Text.Parsing.SequenceParser(
5511 new System.Text.Parsing.SequenceParser(
5512 new System.Text.Parsing.SequenceParser(
5513 new System.Text.Parsing.KeywordParser(ToUtf32("alignof")),
5514 new System.Text.Parsing.CharParser('(')),
5515 new System.Text.Parsing.NonterminalParser(ToUtf32("t5"), ToUtf32("TypeExpr"), 1)),
5516 new System.Text.Parsing.CharParser(')'))))),
5517 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
5518 new System.Text.Parsing.NonterminalParser(ToUtf32("NewExpression"), ToUtf32("NewExpression"), 1))),
5519 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
5520 new System.Text.Parsing.NonterminalParser(ToUtf32("DeleteExpression"), ToUtf32("DeleteExpression"), 1))),
5521 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
5522 new System.Text.Parsing.NonterminalParser(ToUtf32("PostfixExpression"), ToUtf32("PostfixExpression"), 1)))));
5523 AddRule(new UnaryOperatorRule(ToUtf32("UnaryOperator"), GetScope(), Domain()->GetNextRuleId(),
5524 new System.Text.Parsing.AlternativeParser(
5525 new System.Text.Parsing.AlternativeParser(
5526 new System.Text.Parsing.AlternativeParser(
5527 new System.Text.Parsing.AlternativeParser(
5528 new System.Text.Parsing.AlternativeParser(
5529 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5530 new System.Text.Parsing.GroupingParser(
5531 new System.Text.Parsing.DifferenceParser(
5532 new System.Text.Parsing.CharParser('*'),
5533 new System.Text.Parsing.StringParser(ToUtf32("*="))))),
5534 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5535 new System.Text.Parsing.GroupingParser(
5536 new System.Text.Parsing.DifferenceParser(
5537 new System.Text.Parsing.CharParser('&'),
5538 new System.Text.Parsing.StringParser(ToUtf32("&=")))))),
5539 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5540 new System.Text.Parsing.GroupingParser(
5541 new System.Text.Parsing.DifferenceParser(
5542 new System.Text.Parsing.CharParser('+'),
5543 new System.Text.Parsing.StringParser(ToUtf32("+=")))))),
5544 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5545 new System.Text.Parsing.GroupingParser(
5546 new System.Text.Parsing.DifferenceParser(
5547 new System.Text.Parsing.CharParser('-'),
5548 new System.Text.Parsing.StringParser(ToUtf32("-=")))))),
5549 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
5550 new System.Text.Parsing.CharParser('!'))),
5551 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
5552 new System.Text.Parsing.CharParser('~')))));
5553 AddRule(new NewExpressionRule(ToUtf32("NewExpression"), GetScope(), Domain()->GetNextRuleId(),
5554 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5555 new System.Text.Parsing.GroupingParser(
5556 new System.Text.Parsing.SequenceParser(
5557 new System.Text.Parsing.SequenceParser(
5558 new System.Text.Parsing.SequenceParser(
5559 new System.Text.Parsing.KeywordParser(ToUtf32("new")),
5560 new System.Text.Parsing.OptionalParser(
5561 new System.Text.Parsing.NonterminalParser(ToUtf32("NewPlacement"), ToUtf32("NewPlacement"), 1))),
5562 new System.Text.Parsing.NonterminalParser(ToUtf32("NewTypeId"), ToUtf32("NewTypeId"), 1)),
5563 new System.Text.Parsing.OptionalParser(
5564 new System.Text.Parsing.NonterminalParser(ToUtf32("NewInitializer"), ToUtf32("NewInitializer"), 1)))))));
5565 AddRule(new NewPlacementRule(ToUtf32("NewPlacement"), GetScope(), Domain()->GetNextRuleId(),
5566 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5567 new System.Text.Parsing.GroupingParser(
5568 new System.Text.Parsing.SequenceParser(
5569 new System.Text.Parsing.SequenceParser(
5570 new System.Text.Parsing.CharParser('('),
5571 new System.Text.Parsing.NonterminalParser(ToUtf32("ExpressionList"), ToUtf32("ExpressionList"), 1)),
5572 new System.Text.Parsing.CharParser(')'))))));
5573 AddRule(new NewTypeIdRule(ToUtf32("NewTypeId"), GetScope(), Domain()->GetNextRuleId(),
5574 new System.Text.Parsing.SequenceParser(
5575 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5576 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1)),
5577 new System.Text.Parsing.OptionalParser(
5578 new System.Text.Parsing.GroupingParser(
5579 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5580 new System.Text.Parsing.NonterminalParser(ToUtf32("size"), ToUtf32("NewDeclarator"), 1)))))));
5581 AddRule(new NewDeclaratorRule(ToUtf32("NewDeclarator"), GetScope(), Domain()->GetNextRuleId(),
5582 new System.Text.Parsing.SequenceParser(
5583 new System.Text.Parsing.SequenceParser(
5584 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5585 new System.Text.Parsing.CharParser('[')),
5586 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5587 new System.Text.Parsing.NonterminalParser(ToUtf32("size"), ToUtf32("Expression"), 1))),
5588 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5589 new System.Text.Parsing.CharParser(']')))));
5590 AddRule(new NewInitializerRule(ToUtf32("NewInitializer"), GetScope(), Domain()->GetNextRuleId(),
5591 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5592 new System.Text.Parsing.GroupingParser(
5593 new System.Text.Parsing.SequenceParser(
5594 new System.Text.Parsing.SequenceParser(
5595 new System.Text.Parsing.CharParser('('),
5596 new System.Text.Parsing.NonterminalParser(ToUtf32("args"), ToUtf32("PossiblyEmptyArgumentList"), 1)),
5597 new System.Text.Parsing.CharParser(')'))))));
5598 AddRule(new DeleteExpressionRule(ToUtf32("DeleteExpression"), GetScope(), Domain()->GetNextRuleId(),
5599 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5600 new System.Text.Parsing.GroupingParser(
5601 new System.Text.Parsing.SequenceParser(
5602 new System.Text.Parsing.SequenceParser(
5603 new System.Text.Parsing.KeywordParser(ToUtf32("delete")),
5604 new System.Text.Parsing.OptionalParser(
5605 new System.Text.Parsing.GroupingParser(
5606 new System.Text.Parsing.SequenceParser(
5607 new System.Text.Parsing.CharParser('['),
5608 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5609 new System.Text.Parsing.CharParser(']')))))),
5610 new System.Text.Parsing.NonterminalParser(ToUtf32("CastExpression"), ToUtf32("CastExpression"), 1))))));
5611 AddRule(new PostfixExpressionRule(ToUtf32("PostfixExpression"), GetScope(), Domain()->GetNextRuleId(),
5612 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5613 new System.Text.Parsing.GroupingParser(
5614 new System.Text.Parsing.SequenceParser(
5615 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5616 new System.Text.Parsing.NonterminalParser(ToUtf32("PrimaryExpression"), ToUtf32("PrimaryExpression"), 1)),
5617 new System.Text.Parsing.KleeneStarParser(
5618 new System.Text.Parsing.GroupingParser(
5619 new System.Text.Parsing.AlternativeParser(
5620 new System.Text.Parsing.AlternativeParser(
5621 new System.Text.Parsing.AlternativeParser(
5622 new System.Text.Parsing.AlternativeParser(
5623 new System.Text.Parsing.AlternativeParser(
5624 new System.Text.Parsing.SequenceParser(
5625 new System.Text.Parsing.SequenceParser(
5626 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5627 new System.Text.Parsing.CharParser('[')),
5628 new System.Text.Parsing.NonterminalParser(ToUtf32("subscript"), ToUtf32("Expression"), 1)),
5629 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5630 new System.Text.Parsing.CharParser(']'))),
5631 new System.Text.Parsing.SequenceParser(
5632 new System.Text.Parsing.SequenceParser(
5633 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
5634 new System.Text.Parsing.CharParser('(')),
5635 new System.Text.Parsing.NonterminalParser(ToUtf32("arguments"), ToUtf32("PossiblyEmptyArgumentList"), 1)),
5636 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
5637 new System.Text.Parsing.CharParser(')')))),
5638 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
5639 new System.Text.Parsing.GroupingParser(
5640 new System.Text.Parsing.SequenceParser(
5641 new System.Text.Parsing.GroupingParser(
5642 new System.Text.Parsing.DifferenceParser(
5643 new System.Text.Parsing.CharParser('.'),
5644 new System.Text.Parsing.StringParser(ToUtf32(".*")))),
5645 new System.Text.Parsing.NonterminalParser(ToUtf32("id1"), ToUtf32("IdExpression"), 1))))),
5646 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
5647 new System.Text.Parsing.GroupingParser(
5648 new System.Text.Parsing.SequenceParser(
5649 new System.Text.Parsing.GroupingParser(
5650 new System.Text.Parsing.DifferenceParser(
5651 new System.Text.Parsing.StringParser(ToUtf32("->")),
5652 new System.Text.Parsing.StringParser(ToUtf32("->*")))),
5653 new System.Text.Parsing.NonterminalParser(ToUtf32("id2"), ToUtf32("IdExpression"), 1))))),
5654 new System.Text.Parsing.ActionParser(ToUtf32("A8"),
5655 new System.Text.Parsing.StringParser(ToUtf32("++")))),
5656 new System.Text.Parsing.ActionParser(ToUtf32("A9"),
5657 new System.Text.Parsing.StringParser(ToUtf32("--")))))))))));
5658 AddRule(new PrimaryExpressionRule(ToUtf32("PrimaryExpression"), GetScope(), Domain()->GetNextRuleId(),
5659 new System.Text.Parsing.AlternativeParser(
5660 new System.Text.Parsing.AlternativeParser(
5661 new System.Text.Parsing.AlternativeParser(
5662 new System.Text.Parsing.AlternativeParser(
5663 new System.Text.Parsing.AlternativeParser(
5664 new System.Text.Parsing.AlternativeParser(
5665 new System.Text.Parsing.AlternativeParser(
5666 new System.Text.Parsing.AlternativeParser(
5667 new System.Text.Parsing.AlternativeParser(
5668 new System.Text.Parsing.AlternativeParser(
5669 new System.Text.Parsing.AlternativeParser(
5670 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5671 new System.Text.Parsing.NonterminalParser(ToUtf32("Literal"), ToUtf32("Literal"), 0)),
5672 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5673 new System.Text.Parsing.KeywordParser(ToUtf32("this")))),
5674 new System.Text.Parsing.SequenceParser(
5675 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5676 new System.Text.Parsing.EmptyParser()),
5677 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5678 new System.Text.Parsing.NonterminalParser(ToUtf32("DefinedExpr"), ToUtf32("DefinedExpr"), 0)))),
5679 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
5680 new System.Text.Parsing.GroupingParser(
5681 new System.Text.Parsing.SequenceParser(
5682 new System.Text.Parsing.SequenceParser(
5683 new System.Text.Parsing.CharParser('('),
5684 new System.Text.Parsing.NonterminalParser(ToUtf32("expr"), ToUtf32("Expression"), 1)),
5685 new System.Text.Parsing.CharParser(')'))))),
5686 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
5687 new System.Text.Parsing.NonterminalParser(ToUtf32("CppCastExpression"), ToUtf32("CppCastExpression"), 1))),
5688 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
5689 new System.Text.Parsing.NonterminalParser(ToUtf32("TypeIdExpression"), ToUtf32("TypeIdExpression"), 1))),
5690 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
5691 new System.Text.Parsing.GroupingParser(
5692 new System.Text.Parsing.SequenceParser(
5693 new System.Text.Parsing.SequenceParser(
5694 new System.Text.Parsing.SequenceParser(
5695 new System.Text.Parsing.NonterminalParser(ToUtf32("s1"), ToUtf32("SimpleTypeSpecifier"), 0),
5696 new System.Text.Parsing.CharParser('(')),
5697 new System.Text.Parsing.NonterminalParser(ToUtf32("args1"), ToUtf32("PossiblyEmptyArgumentList"), 1)),
5698 new System.Text.Parsing.CharParser(')'))))),
5699 new System.Text.Parsing.ActionParser(ToUtf32("A8"),
5700 new System.Text.Parsing.GroupingParser(
5701 new System.Text.Parsing.SequenceParser(
5702 new System.Text.Parsing.NonterminalParser(ToUtf32("s2"), ToUtf32("SimpleTypeSpecifier"), 0),
5703 new System.Text.Parsing.NonterminalParser(ToUtf32("b1"), ToUtf32("BracedInitializerList"), 1))))),
5704 new System.Text.Parsing.ActionParser(ToUtf32("A9"),
5705 new System.Text.Parsing.GroupingParser(
5706 new System.Text.Parsing.SequenceParser(
5707 new System.Text.Parsing.SequenceParser(
5708 new System.Text.Parsing.SequenceParser(
5709 new System.Text.Parsing.NonterminalParser(ToUtf32("t1"), ToUtf32("TypeExpr"), 1),
5710 new System.Text.Parsing.CharParser('(')),
5711 new System.Text.Parsing.NonterminalParser(ToUtf32("args2"), ToUtf32("PossiblyEmptyArgumentList"), 1)),
5712 new System.Text.Parsing.CharParser(')'))))),
5713 new System.Text.Parsing.ActionParser(ToUtf32("A10"),
5714 new System.Text.Parsing.GroupingParser(
5715 new System.Text.Parsing.SequenceParser(
5716 new System.Text.Parsing.NonterminalParser(ToUtf32("t2"), ToUtf32("TypeExpr"), 1),
5717 new System.Text.Parsing.NonterminalParser(ToUtf32("b2"), ToUtf32("BracedInitializerList"), 1))))),
5718 new System.Text.Parsing.ActionParser(ToUtf32("A11"),
5719 new System.Text.Parsing.NonterminalParser(ToUtf32("IdExpression"), ToUtf32("IdExpression"), 1))),
5720 new System.Text.Parsing.ActionParser(ToUtf32("A12"),
5721 new System.Text.Parsing.NonterminalParser(ToUtf32("LambdaExpression"), ToUtf32("LambdaExpression"), 1)))));
5722 AddRule(new CppCastExpressionRule(ToUtf32("CppCastExpression"), GetScope(), Domain()->GetNextRuleId(),
5723 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5724 new System.Text.Parsing.GroupingParser(
5725 new System.Text.Parsing.SequenceParser(
5726 new System.Text.Parsing.SequenceParser(
5727 new System.Text.Parsing.SequenceParser(
5728 new System.Text.Parsing.SequenceParser(
5729 new System.Text.Parsing.SequenceParser(
5730 new System.Text.Parsing.SequenceParser(
5731 new System.Text.Parsing.GroupingParser(
5732 new System.Text.Parsing.AlternativeParser(
5733 new System.Text.Parsing.AlternativeParser(
5734 new System.Text.Parsing.AlternativeParser(
5735 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5736 new System.Text.Parsing.KeywordParser(ToUtf32("dynamic_cast"))),
5737 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5738 new System.Text.Parsing.KeywordParser(ToUtf32("static_cast")))),
5739 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5740 new System.Text.Parsing.KeywordParser(ToUtf32("reinterpret_cast")))),
5741 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
5742 new System.Text.Parsing.KeywordParser(ToUtf32("const_cast"))))),
5743 new System.Text.Parsing.CharParser('<')),
5744 new System.Text.Parsing.NonterminalParser(ToUtf32("t1"), ToUtf32("TypeExpr"), 1)),
5745 new System.Text.Parsing.CharParser('>')),
5746 new System.Text.Parsing.CharParser('(')),
5747 new System.Text.Parsing.NonterminalParser(ToUtf32("e1"), ToUtf32("Expression"), 1)),
5748 new System.Text.Parsing.CharParser(')'))))));
5749 AddRule(new DefinedExprRule(ToUtf32("DefinedExpr"), GetScope(), Domain()->GetNextRuleId(),
5750 new System.Text.Parsing.AlternativeParser(
5751 new System.Text.Parsing.AlternativeParser(
5752 new System.Text.Parsing.AlternativeParser(
5753 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5754 new System.Text.Parsing.GroupingParser(
5755 new System.Text.Parsing.SequenceParser(
5756 new System.Text.Parsing.SequenceParser(
5757 new System.Text.Parsing.SequenceParser(
5758 new System.Text.Parsing.KeywordParser(ToUtf32("defined")),
5759 new System.Text.Parsing.CharParser('(')),
5760 new System.Text.Parsing.NonterminalParser(ToUtf32("id1"), ToUtf32("identifier"), 0)),
5761 new System.Text.Parsing.CharParser(')')))),
5762 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5763 new System.Text.Parsing.GroupingParser(
5764 new System.Text.Parsing.SequenceParser(
5765 new System.Text.Parsing.KeywordParser(ToUtf32("defined")),
5766 new System.Text.Parsing.NonterminalParser(ToUtf32("id2"), ToUtf32("identifier"), 0))))),
5767 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5768 new System.Text.Parsing.GroupingParser(
5769 new System.Text.Parsing.SequenceParser(
5770 new System.Text.Parsing.SequenceParser(
5771 new System.Text.Parsing.SequenceParser(
5772 new System.Text.Parsing.KeywordParser(ToUtf32("defined")),
5773 new System.Text.Parsing.CharParser('(')),
5774 new System.Text.Parsing.NonterminalParser(ToUtf32("lit1"), ToUtf32("Literal"), 0)),
5775 new System.Text.Parsing.CharParser(')'))))),
5776 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5777 new System.Text.Parsing.GroupingParser(
5778 new System.Text.Parsing.SequenceParser(
5779 new System.Text.Parsing.KeywordParser(ToUtf32("defined")),
5780 new System.Text.Parsing.NonterminalParser(ToUtf32("lit2"), ToUtf32("Literal"), 0)))))));
5781 AddRule(new TypeIdExpressionRule(ToUtf32("TypeIdExpression"), GetScope(), Domain()->GetNextRuleId(),
5782 new System.Text.Parsing.AlternativeParser(
5783 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5784 new System.Text.Parsing.GroupingParser(
5785 new System.Text.Parsing.SequenceParser(
5786 new System.Text.Parsing.SequenceParser(
5787 new System.Text.Parsing.SequenceParser(
5788 new System.Text.Parsing.KeywordParser(ToUtf32("typeid")),
5789 new System.Text.Parsing.CharParser('(')),
5790 new System.Text.Parsing.NonterminalParser(ToUtf32("t1"), ToUtf32("TypeExpr"), 1)),
5791 new System.Text.Parsing.CharParser(')')))),
5792 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5793 new System.Text.Parsing.GroupingParser(
5794 new System.Text.Parsing.SequenceParser(
5795 new System.Text.Parsing.SequenceParser(
5796 new System.Text.Parsing.SequenceParser(
5797 new System.Text.Parsing.KeywordParser(ToUtf32("typeid")),
5798 new System.Text.Parsing.CharParser('(')),
5799 new System.Text.Parsing.NonterminalParser(ToUtf32("e1"), ToUtf32("Expression"), 1)),
5800 new System.Text.Parsing.CharParser(')')))))));
5801 AddRule(new IdExpressionRule(ToUtf32("IdExpression"), GetScope(), Domain()->GetNextRuleId(),
5802 new System.Text.Parsing.AlternativeParser(
5803 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5804 new System.Text.Parsing.NonterminalParser(ToUtf32("QualifiedIdExpr"), ToUtf32("QualifiedIdExpr"), 1)),
5805 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5806 new System.Text.Parsing.NonterminalParser(ToUtf32("UnqualifiedIdExpr"), ToUtf32("UnqualifiedIdExpr"), 1)))));
5807 AddRule(new UnqualifiedIdExprRule(ToUtf32("UnqualifiedIdExpr"), GetScope(), Domain()->GetNextRuleId(),
5808 new System.Text.Parsing.AlternativeParser(
5809 new System.Text.Parsing.AlternativeParser(
5810 new System.Text.Parsing.AlternativeParser(
5811 new System.Text.Parsing.AlternativeParser(
5812 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5813 new System.Text.Parsing.NonterminalParser(ToUtf32("TemplateId"), ToUtf32("TemplateId"), 1)),
5814 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5815 new System.Text.Parsing.NonterminalParser(ToUtf32("id1"), ToUtf32("Identifier"), 0))),
5816 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5817 new System.Text.Parsing.NonterminalParser(ToUtf32("OperatorFunctionId"), ToUtf32("OperatorFunctionId"), 0))),
5818 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5819 new System.Text.Parsing.NonterminalParser(ToUtf32("ConversionFunctionId"), ToUtf32("ConversionFunctionId"), 1))),
5820 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
5821 new System.Text.Parsing.GroupingParser(
5822 new System.Text.Parsing.SequenceParser(
5823 new System.Text.Parsing.CharParser('~'),
5824 new System.Text.Parsing.NonterminalParser(ToUtf32("id2"), ToUtf32("Identifier"), 0)))))));
5825 AddRule(new QualifiedIdExprRule(ToUtf32("QualifiedIdExpr"), GetScope(), Domain()->GetNextRuleId(),
5826 new System.Text.Parsing.AlternativeParser(
5827 new System.Text.Parsing.AlternativeParser(
5828 new System.Text.Parsing.AlternativeParser(
5829 new System.Text.Parsing.AlternativeParser(
5830 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5831 new System.Text.Parsing.GroupingParser(
5832 new System.Text.Parsing.SequenceParser(
5833 new System.Text.Parsing.StringParser(ToUtf32("::")),
5834 new System.Text.Parsing.NonterminalParser(ToUtf32("TemplateId"), ToUtf32("TemplateId"), 1)))),
5835 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5836 new System.Text.Parsing.GroupingParser(
5837 new System.Text.Parsing.SequenceParser(
5838 new System.Text.Parsing.SequenceParser(
5839 new System.Text.Parsing.StringParser(ToUtf32("::")),
5840 new System.Text.Parsing.NonterminalParser(ToUtf32("ns"), ToUtf32("NestedNameSpecifier"), 1)),
5841 new System.Text.Parsing.NonterminalParser(ToUtf32("ud1"), ToUtf32("UnqualifiedIdExpr"), 1))))),
5842 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5843 new System.Text.Parsing.GroupingParser(
5844 new System.Text.Parsing.SequenceParser(
5845 new System.Text.Parsing.StringParser(ToUtf32("::")),
5846 new System.Text.Parsing.NonterminalParser(ToUtf32("Identifier"), ToUtf32("Identifier"), 0))))),
5847 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5848 new System.Text.Parsing.GroupingParser(
5849 new System.Text.Parsing.SequenceParser(
5850 new System.Text.Parsing.StringParser(ToUtf32("::")),
5851 new System.Text.Parsing.NonterminalParser(ToUtf32("OperatorFunctionId"), ToUtf32("OperatorFunctionId"), 0))))),
5852 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
5853 new System.Text.Parsing.GroupingParser(
5854 new System.Text.Parsing.SequenceParser(
5855 new System.Text.Parsing.NonterminalParser(ToUtf32("ns2"), ToUtf32("NestedNameSpecifier"), 1),
5856 new System.Text.Parsing.NonterminalParser(ToUtf32("uid2"), ToUtf32("UnqualifiedIdExpr"), 1)))))));
5857 AddRule(new OperatorFunctionIdRule(ToUtf32("OperatorFunctionId"), GetScope(), Domain()->GetNextRuleId(),
5858 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5859 new System.Text.Parsing.GroupingParser(
5860 new System.Text.Parsing.SequenceParser(
5861 new System.Text.Parsing.KeywordParser(ToUtf32("operator")),
5862 new System.Text.Parsing.NonterminalParser(ToUtf32("Operator"), ToUtf32("Operator"), 0))))));
5863 AddRule(new OperatorRule(ToUtf32("Operator"), GetScope(), Domain()->GetNextRuleId(),
5864 new System.Text.Parsing.AlternativeParser(
5865 new System.Text.Parsing.AlternativeParser(
5866 new System.Text.Parsing.AlternativeParser(
5867 new System.Text.Parsing.AlternativeParser(
5868 new System.Text.Parsing.AlternativeParser(
5869 new System.Text.Parsing.AlternativeParser(
5870 new System.Text.Parsing.AlternativeParser(
5871 new System.Text.Parsing.AlternativeParser(
5872 new System.Text.Parsing.AlternativeParser(
5873 new System.Text.Parsing.AlternativeParser(
5874 new System.Text.Parsing.AlternativeParser(
5875 new System.Text.Parsing.AlternativeParser(
5876 new System.Text.Parsing.AlternativeParser(
5877 new System.Text.Parsing.AlternativeParser(
5878 new System.Text.Parsing.AlternativeParser(
5879 new System.Text.Parsing.AlternativeParser(
5880 new System.Text.Parsing.AlternativeParser(
5881 new System.Text.Parsing.AlternativeParser(
5882 new System.Text.Parsing.AlternativeParser(
5883 new System.Text.Parsing.AlternativeParser(
5884 new System.Text.Parsing.AlternativeParser(
5885 new System.Text.Parsing.AlternativeParser(
5886 new System.Text.Parsing.AlternativeParser(
5887 new System.Text.Parsing.AlternativeParser(
5888 new System.Text.Parsing.AlternativeParser(
5889 new System.Text.Parsing.AlternativeParser(
5890 new System.Text.Parsing.AlternativeParser(
5891 new System.Text.Parsing.AlternativeParser(
5892 new System.Text.Parsing.AlternativeParser(
5893 new System.Text.Parsing.AlternativeParser(
5894 new System.Text.Parsing.AlternativeParser(
5895 new System.Text.Parsing.AlternativeParser(
5896 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5897 new System.Text.Parsing.GroupingParser(
5898 new System.Text.Parsing.SequenceParser(
5899 new System.Text.Parsing.KeywordParser(ToUtf32("new")),
5900 new System.Text.Parsing.StringParser(ToUtf32("[]"))))),
5901 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5902 new System.Text.Parsing.GroupingParser(
5903 new System.Text.Parsing.SequenceParser(
5904 new System.Text.Parsing.KeywordParser(ToUtf32("delete")),
5905 new System.Text.Parsing.StringParser(ToUtf32("[]")))))),
5906 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5907 new System.Text.Parsing.KeywordParser(ToUtf32("new")))),
5908 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
5909 new System.Text.Parsing.KeywordParser(ToUtf32("delete")))),
5910 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
5911 new System.Text.Parsing.NonterminalParser(ToUtf32("AssignmentOperator"), ToUtf32("AssignmentOperator"), 0))),
5912 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
5913 new System.Text.Parsing.StringParser(ToUtf32("++")))),
5914 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
5915 new System.Text.Parsing.StringParser(ToUtf32("--")))),
5916 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
5917 new System.Text.Parsing.StringParser(ToUtf32("<<")))),
5918 new System.Text.Parsing.ActionParser(ToUtf32("A8"),
5919 new System.Text.Parsing.StringParser(ToUtf32(">>")))),
5920 new System.Text.Parsing.ActionParser(ToUtf32("A9"),
5921 new System.Text.Parsing.StringParser(ToUtf32("&&")))),
5922 new System.Text.Parsing.ActionParser(ToUtf32("A10"),
5923 new System.Text.Parsing.StringParser(ToUtf32("||")))),
5924 new System.Text.Parsing.ActionParser(ToUtf32("A11"),
5925 new System.Text.Parsing.StringParser(ToUtf32("==")))),
5926 new System.Text.Parsing.ActionParser(ToUtf32("A12"),
5927 new System.Text.Parsing.StringParser(ToUtf32("!=")))),
5928 new System.Text.Parsing.ActionParser(ToUtf32("A13"),
5929 new System.Text.Parsing.StringParser(ToUtf32("<=")))),
5930 new System.Text.Parsing.ActionParser(ToUtf32("A14"),
5931 new System.Text.Parsing.StringParser(ToUtf32(">=")))),
5932 new System.Text.Parsing.ActionParser(ToUtf32("A15"),
5933 new System.Text.Parsing.StringParser(ToUtf32(".*")))),
5934 new System.Text.Parsing.ActionParser(ToUtf32("A16"),
5935 new System.Text.Parsing.StringParser(ToUtf32("->*")))),
5936 new System.Text.Parsing.ActionParser(ToUtf32("A17"),
5937 new System.Text.Parsing.StringParser(ToUtf32("->")))),
5938 new System.Text.Parsing.ActionParser(ToUtf32("A18"),
5939 new System.Text.Parsing.StringParser(ToUtf32("()")))),
5940 new System.Text.Parsing.ActionParser(ToUtf32("A19"),
5941 new System.Text.Parsing.StringParser(ToUtf32("[]")))),
5942 new System.Text.Parsing.ActionParser(ToUtf32("A20"),
5943 new System.Text.Parsing.CharParser('<'))),
5944 new System.Text.Parsing.ActionParser(ToUtf32("A21"),
5945 new System.Text.Parsing.CharParser('>'))),
5946 new System.Text.Parsing.ActionParser(ToUtf32("A22"),
5947 new System.Text.Parsing.CharParser('+'))),
5948 new System.Text.Parsing.ActionParser(ToUtf32("A23"),
5949 new System.Text.Parsing.CharParser('-'))),
5950 new System.Text.Parsing.ActionParser(ToUtf32("A24"),
5951 new System.Text.Parsing.CharParser('*'))),
5952 new System.Text.Parsing.ActionParser(ToUtf32("A25"),
5953 new System.Text.Parsing.CharParser('/'))),
5954 new System.Text.Parsing.ActionParser(ToUtf32("A26"),
5955 new System.Text.Parsing.CharParser('%'))),
5956 new System.Text.Parsing.ActionParser(ToUtf32("A27"),
5957 new System.Text.Parsing.CharParser('^'))),
5958 new System.Text.Parsing.ActionParser(ToUtf32("A28"),
5959 new System.Text.Parsing.CharParser('&'))),
5960 new System.Text.Parsing.ActionParser(ToUtf32("A29"),
5961 new System.Text.Parsing.CharParser('|'))),
5962 new System.Text.Parsing.ActionParser(ToUtf32("A30"),
5963 new System.Text.Parsing.CharParser('~'))),
5964 new System.Text.Parsing.ActionParser(ToUtf32("A31"),
5965 new System.Text.Parsing.CharParser('!'))),
5966 new System.Text.Parsing.ActionParser(ToUtf32("A32"),
5967 new System.Text.Parsing.CharParser(',')))));
5968 AddRule(new ConversionFunctionIdRule(ToUtf32("ConversionFunctionId"), GetScope(), Domain()->GetNextRuleId(),
5969 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5970 new System.Text.Parsing.GroupingParser(
5971 new System.Text.Parsing.SequenceParser(
5972 new System.Text.Parsing.KeywordParser(ToUtf32("operator")),
5973 new System.Text.Parsing.NonterminalParser(ToUtf32("TypeExpr"), ToUtf32("TypeExpr"), 1))))));
5974 AddRule(new LambdaExpressionRule(ToUtf32("LambdaExpression"), GetScope(), Domain()->GetNextRuleId(),
5975 new System.Text.Parsing.SequenceParser(
5976 new System.Text.Parsing.SequenceParser(
5977 new System.Text.Parsing.SequenceParser(
5978 new System.Text.Parsing.SequenceParser(
5979 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5980 new System.Text.Parsing.CharParser('[')),
5981 new System.Text.Parsing.NonterminalParser(ToUtf32("LambdaCaptures"), ToUtf32("LambdaCaptures"), 1)),
5982 new System.Text.Parsing.ExpectationParser(
5983 new System.Text.Parsing.CharParser(']'))),
5984 new System.Text.Parsing.OptionalParser(
5985 new System.Text.Parsing.GroupingParser(
5986 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
5987 new System.Text.Parsing.NonterminalParser(ToUtf32("ParameterList"), ToUtf32("ParameterList"), 1))))),
5988 new System.Text.Parsing.ExpectationParser(
5989 new System.Text.Parsing.GroupingParser(
5990 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
5991 new System.Text.Parsing.NonterminalParser(ToUtf32("CompoundStatement"), ToUtf32("CompoundStatement"), 1)))))));
5992 AddRule(new LambdaCapturesRule(ToUtf32("LambdaCaptures"), GetScope(), Domain()->GetNextRuleId(),
5993 new System.Text.Parsing.SequenceParser(
5994 new System.Text.Parsing.OptionalParser(
5995 new System.Text.Parsing.GroupingParser(
5996 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
5997 new System.Text.Parsing.NonterminalParser(ToUtf32("CaptureDefault"), ToUtf32("CaptureDefault"), 0)))),
5998 new System.Text.Parsing.OptionalParser(
5999 new System.Text.Parsing.NonterminalParser(ToUtf32("Captures"), ToUtf32("Captures"), 1)))));
6000 AddRule(new CaptureDefaultRule(ToUtf32("CaptureDefault"), GetScope(), Domain()->GetNextRuleId(),
6001 new System.Text.Parsing.AlternativeParser(
6002 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
6003 new System.Text.Parsing.CharParser('=')),
6004 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
6005 new System.Text.Parsing.CharParser('&')))));
6006 AddRule(new CapturesRule(ToUtf32("Captures"), GetScope(), Domain()->GetNextRuleId(),
6007 new System.Text.Parsing.SequenceParser(
6008 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
6009 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Capture"), 0)),
6010 new System.Text.Parsing.KleeneStarParser(
6011 new System.Text.Parsing.GroupingParser(
6012 new System.Text.Parsing.SequenceParser(
6013 new System.Text.Parsing.CharParser(','),
6014 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
6015 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Capture"), 0))))))));
6016 AddRule(new CaptureRule(ToUtf32("Capture"), GetScope(), Domain()->GetNextRuleId(),
6017 new System.Text.Parsing.AlternativeParser(
6018 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
6019 new System.Text.Parsing.NonterminalParser(ToUtf32("Identifier"), ToUtf32("Identifier"), 0)),
6020 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
6021 new System.Text.Parsing.KeywordParser(ToUtf32("this"))))));
6022 }
6023 }
6024 }
6025 namespace cppparser
6026 {
6027 public class ConstantExpressionGrammar : System.Text.Parsing.Grammar
6028 {
6029 public ConstantExpressionGrammar() : this(new ParsingDomain())
6030 {
6031 }
6032 public ConstantExpressionGrammar(ParsingDomain* parsingDomain) : base(ToUtf32("ConstantExpressionGrammar"), parsingDomain->GetNamespaceScope(ToUtf32("cppparser")), parsingDomain)
6033 {
6034 SetOwner(0);
6035 RegisterParsingDomain(parsingDomain);
6036 parsingDomain->AddGrammar(this);
6037 CreateRules();
6038 Link();
6039 }
6040 public Node* Parse(const uchar* start, const uchar* end, int fileIndex, const string& fileName, ParsingContext* ctx)
6041 {
6042 Scanner scanner(start, end, fileName, fileIndex, SkipRule());
6043 UniquePtr<XmlLog> xmlLog;
6044 if (Log() != null)
6045 {
6046 xmlLog.Reset(new XmlLog(*Log(), MaxLogLineLength()));
6047 scanner.SetLog(xmlLog.Get());
6048 xmlLog->WriteBeginRule( u"parse");
6049 xmlLog->IncIndent();
6050 }
6051 Stack<UniquePtr<Object>> stack;
6052 UniquePtr<ParsingData> parsingData(new ParsingData(Domain()->NumRules()));
6053 scanner.SetParsingData(parsingData.Get());
6054 stack.Push(UniquePtr<Object>(new ValueObject<ParsingContext*>(ctx)));
6055 Match match = base->Parse(scanner, stack, parsingData.Get());
6056 Span stop = scanner.GetSpan();
6057 if (Log() != null)
6058 {
6059 xmlLog->DecIndent();
6060 xmlLog->WriteEndRule( u"parse");
6061 }
6062 if (!match.Hit() || stop.start != cast<int>(end - start))
6063 {
6064 if (StartRule() != null)
6065 {
6066 throw ExpectationFailure(StartRule()->Info(), fileName, stop, start, end);
6067 }
6068 else
6069 {
6070 throw ParsingException("grammar '" + ToUtf8(Name()) + "' has no start rule", fileName, scanner.GetSpan(), start, end);
6071 }
6072 }
6073 UniquePtr<Object> value = stack.Pop();
6074 Node* result = *cast<ValueObject<Node*>*>(value.Get());
6075 return result;
6076 }
6077
6078 public override void GetReferencedGrammars()
6079 {
6080 ParsingDomain* pd = Domain();
6081 Grammar* grammar0 = pd->GetGrammar(ToUtf32("cppparser.ExpressionGrammar"));
6082 if (grammar0 == null)
6083 {
6084 grammar0 = new cppparser.ExpressionGrammar(pd);
6085 }
6086 AddGrammarReference(grammar0);
6087 Grammar* grammar1 = pd->GetGrammar(ToUtf32("System.Text.Parsing.stdlib"));
6088 if (grammar1 == null)
6089 {
6090 grammar1 = new System.Text.Parsing.stdlib(pd);
6091 }
6092 AddGrammarReference(grammar1);
6093 }
6094 public override void CreateRules()
6095 {
6096 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("ConstantExpression"), this, ToUtf32("ExpressionGrammar.ConstantExpression")));
6097 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("spaces"), this, ToUtf32("System.Text.Parsing.stdlib.spaces")));
6098 SetStartRuleName(ToUtf32("ConstantExpression"));
6099 SetSkipRuleName(ToUtf32("spaces"));
6100 }
6101 }
6102 }